]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Use new namespace qualifications of distributed vectors in library
authorMartin Kronbichler <kronbichler@lnm.mw.tum.de>
Wed, 15 Jun 2016 08:47:22 +0000 (10:47 +0200)
committerMartin Kronbichler <kronbichler@lnm.mw.tum.de>
Wed, 15 Jun 2016 08:50:38 +0000 (10:50 +0200)
110 files changed:
cmake/config/template-arguments.in
examples/step-48/step-48.cc
include/deal.II/lac/block_vector_base.h
include/deal.II/lac/constraint_matrix.templates.h
include/deal.II/lac/trilinos_precondition.h
include/deal.II/lac/trilinos_solver.h
include/deal.II/lac/trilinos_sparse_matrix.h
include/deal.II/matrix_free/matrix_free.h
include/deal.II/multigrid/mg_transfer.h
include/deal.II/multigrid/mg_transfer.templates.h
include/deal.II/multigrid/mg_transfer_matrix_free.h
include/deal.II/numerics/error_estimator.templates.h
include/deal.II/numerics/vector_tools.templates.h
source/algorithms/operator.cc
source/base/mpi.cc
source/base/time_stepping.cc
source/base/time_stepping.inst.in
source/distributed/solution_transfer.cc
source/distributed/solution_transfer.inst.in
source/dofs/dof_accessor_get.cc
source/dofs/dof_accessor_set.cc
source/dofs/dof_tools_constraints.cc
source/fe/fe_tools_interpolate.cc
source/fe/fe_values.cc
source/lac/constraint_matrix.cc
source/lac/constraint_matrix.inst.in
source/lac/solver.cc
source/lac/sparse_matrix.cc
source/lac/sparse_matrix.inst.in
source/lac/sparse_matrix_inst2.cc
source/lac/trilinos_precondition.cc
source/lac/trilinos_solver.cc
source/lac/trilinos_sparse_matrix.cc
source/lac/vector_memory.cc
source/meshworker/mesh_worker_vector_selector.cc
source/multigrid/mg_base.cc
source/multigrid/mg_level_global_transfer.cc
source/multigrid/mg_level_global_transfer.inst.in
source/multigrid/mg_transfer_matrix_free.cc
source/multigrid/mg_transfer_prebuilt.cc
source/multigrid/multigrid.cc
source/numerics/data_out_dof_data.cc
source/numerics/derivative_approximation.cc
source/numerics/dof_output_operator.cc
source/numerics/error_estimator_1d.cc
source/numerics/fe_field_function.cc
source/numerics/point_value_history.cc
source/numerics/solution_transfer.cc
tests/bits/fe_tools_06b.cc
tests/gla/extract_subvector_to_parallel.cc
tests/lac/vector_reinit_01.cc
tests/matrix_free/matrix_vector_10.cc
tests/matrix_free/matrix_vector_11.cc
tests/matrix_free/matrix_vector_12.cc
tests/matrix_free/matrix_vector_13.cc
tests/matrix_free/matrix_vector_mf.h
tests/matrix_free/parallel_multigrid.cc
tests/matrix_free/parallel_multigrid_adaptive.cc
tests/matrix_free/parallel_multigrid_adaptive_mf.cc
tests/matrix_free/parallel_multigrid_mf.cc
tests/matrix_free/step-48.cc
tests/matrix_free/step-48b.cc
tests/matrix_free/step-48c.cc
tests/mpi/constraint_matrix_crash_01.cc
tests/mpi/constraint_matrix_set_zero_02.cc
tests/mpi/parallel_block_vector_01.cc
tests/mpi/parallel_block_vector_02.cc
tests/mpi/parallel_vector_01.cc
tests/mpi/parallel_vector_02.cc
tests/mpi/parallel_vector_03.cc
tests/mpi/parallel_vector_04.cc
tests/mpi/parallel_vector_05.cc
tests/mpi/parallel_vector_06.cc
tests/mpi/parallel_vector_07.cc
tests/mpi/parallel_vector_08.cc
tests/mpi/parallel_vector_09.cc
tests/mpi/parallel_vector_10.cc
tests/mpi/parallel_vector_11.cc
tests/mpi/parallel_vector_12.cc
tests/mpi/parallel_vector_13.cc
tests/mpi/parallel_vector_14.cc
tests/mpi/parallel_vector_15.cc
tests/mpi/parallel_vector_16.cc
tests/mpi/parallel_vector_17.cc
tests/mpi/parallel_vector_back_interpolate.cc
tests/mpi/parallel_vector_interpolate.cc
tests/mpi/point_value_01.cc
tests/mpi/trilinos_matvec_01.cc
tests/mpi/trilinos_matvec_02.cc
tests/mpi/trilinos_matvec_03.cc
tests/mpi/trilinos_sparse_matrix_01.cc
tests/mpi/trilinos_sparse_matrix_02.cc
tests/mpi/trilinos_sparse_matrix_03.cc
tests/mpi/trilinos_sparse_matrix_04.cc
tests/mpi/trilinos_sparse_matrix_05.cc
tests/multigrid/step-16-04.cc
tests/multigrid/transfer_matrix_free_01.cc
tests/multigrid/transfer_matrix_free_02.cc
tests/multigrid/transfer_matrix_free_03.cc
tests/multigrid/transfer_matrix_free_04.cc
tests/multigrid/transfer_matrix_free_05.cc
tests/multigrid/transfer_matrix_free_06.cc
tests/multigrid/transfer_prebuilt_04.cc
tests/petsc/copy_to_dealvec.cc
tests/petsc/copy_to_dealvec_block.cc
tests/petsc_complex/fe_get_function_values.cc
tests/trilinos/copy_to_dealvec.cc
tests/trilinos/copy_to_dealvec_block.cc
tests/trilinos/sparse_matrix_vector_10.cc
tests/trilinos/sparse_matrix_vector_11.cc

index ec553ea34de8085f1b8194b1070319be4cada08a..a9d69a2c2a96131f70b4ce0bc9ab28f6e64fa879 100644 (file)
@@ -26,8 +26,8 @@ SERIAL_VECTORS := { Vector<double>;
                     LinearAlgebra::distributed::Vector<double>;
                     LinearAlgebra::distributed::Vector<float> ;
 
-                    parallel::distributed::BlockVector<double>;
-                    parallel::distributed::BlockVector<float> ;
+                    LinearAlgebra::distributed::BlockVector<double>;
+                    LinearAlgebra::distributed::BlockVector<float> ;
 
                     @DEAL_II_EXPAND_TRILINOS_VECTOR@;
                     @DEAL_II_EXPAND_TRILINOS_MPI_VECTOR@;
@@ -46,11 +46,11 @@ REAL_SERIAL_VECTORS := { Vector<double>;
                     BlockVector<double>;
                     BlockVector<float>;
 
-                    parallel::distributed::Vector<double>;
-                    parallel::distributed::Vector<float> ;
+                    LinearAlgebra::distributed::Vector<double>;
+                    LinearAlgebra::distributed::Vector<float> ;
 
-                    parallel::distributed::BlockVector<double>;
-                    parallel::distributed::BlockVector<float> ;
+                    LinearAlgebra::distributed::BlockVector<double>;
+                    LinearAlgebra::distributed::BlockVector<float> ;
 
                     @DEAL_II_EXPAND_TRILINOS_VECTOR@;
                     @DEAL_II_EXPAND_TRILINOS_MPI_VECTOR@;
@@ -81,7 +81,7 @@ VECTORS_WITH_MATRIX := { Vector<double>;
                     BlockVector<double>;
                     BlockVector<float>;
 
-                    parallel::distributed::Vector<double>;
+                    LinearAlgebra::distributed::Vector<double>;
 
                     @DEAL_II_EXPAND_TRILINOS_VECTOR@;
                     @DEAL_II_EXPAND_TRILINOS_MPI_VECTOR@;
index df18653e277b2ad0360992cc620845e7ec28da7b..7233333d54563d7e1cc92e9dcbc49c69bea45cd8 100644 (file)
@@ -38,7 +38,7 @@
 
 // This includes the data structures for the efficient implementation of
 // matrix-free methods.
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/matrix_free/matrix_free.h>
 #include <deal.II/matrix_free/fe_evaluation.h>
 
@@ -83,17 +83,17 @@ namespace Step48
     SineGordonOperation(const MatrixFree<dim,double> &data_in,
                         const double                  time_step);
 
-    void apply (parallel::distributed::Vector<double>                     &dst,
-                const std::vector<parallel::distributed::Vector<double>*> &src) const;
+    void apply (LinearAlgebra::distributed::Vector<double>                     &dst,
+                const std::vector<LinearAlgebra::distributed::Vector<double>*> &src) const;
 
   private:
     const MatrixFree<dim,double>         &data;
     const VectorizedArray<double>         delta_t_sqr;
-    parallel::distributed::Vector<double> inv_mass_matrix;
+    LinearAlgebra::distributed::Vector<double> inv_mass_matrix;
 
     void local_apply (const MatrixFree<dim,double>               &data,
-                      parallel::distributed::Vector<double>      &dst,
-                      const std::vector<parallel::distributed::Vector<double>*> &src,
+                      LinearAlgebra::distributed::Vector<double>      &dst,
+                      const std::vector<LinearAlgebra::distributed::Vector<double>*> &src,
                       const std::pair<unsigned int,unsigned int> &cell_range) const;
   };
 
@@ -169,7 +169,7 @@ namespace Step48
   // one destination vector, even if we happen to use many vectors like the two
   // in this case. Note that the cell loop accepts any valid class for input and
   // output, which does not only include vectors but general data types.
-  // However, only in case it encounters a parallel::distributed::Vector<Number>
+  // However, only in case it encounters a LinearAlgebra::distributed::Vector<Number>
   // or a <tt>std::vector</tt> collecting these vectors, it calls functions that
   // exchange data at the beginning and the end of the loop. In the loop over
   // the cells, we first have to read in the values in the vectors related to
@@ -181,8 +181,8 @@ namespace Step48
   template <int dim, int fe_degree>
   void SineGordonOperation<dim, fe_degree>::
   local_apply (const MatrixFree<dim>                      &data,
-               parallel::distributed::Vector<double>      &dst,
-               const std::vector<parallel::distributed::Vector<double>*> &src,
+               LinearAlgebra::distributed::Vector<double>      &dst,
+               const std::vector<LinearAlgebra::distributed::Vector<double>*> &src,
                const std::pair<unsigned int,unsigned int> &cell_range) const
   {
     AssertDimension (src.size(), 2);
@@ -228,8 +228,8 @@ namespace Step48
   // provide a function with the same signature that is not part of a class.
   template <int dim, int fe_degree>
   void SineGordonOperation<dim, fe_degree>::
-  apply (parallel::distributed::Vector<double>                     &dst,
-         const std::vector<parallel::distributed::Vector<double>*> &src) const
+  apply (LinearAlgebra::distributed::Vector<double>                     &dst,
+         const std::vector<LinearAlgebra::distributed::Vector<double>*> &src) const
   {
     dst = 0;
     data.cell_loop (&SineGordonOperation<dim,fe_degree>::local_apply,
@@ -303,7 +303,7 @@ namespace Step48
 
     MatrixFree<dim,double> matrix_free_data;
 
-    parallel::distributed::Vector<double> solution, old_solution, old_old_solution;
+    LinearAlgebra::distributed::Vector<double> solution, old_solution, old_old_solution;
 
     const unsigned int n_global_refinements;
     double time, time_step;
@@ -442,7 +442,7 @@ namespace Step48
   // the integrate_difference function as well as in DataOut. We only need to
   // make sure that we tell the vector to update its ghost values before we
   // read them. This is a feature present only in the
-  // parallel::distributed::Vector class. Distributed vectors with PETSc and
+  // LinearAlgebra::distributed::Vector class. Distributed vectors with PETSc and
   // Trilinos, on the other hand, need to be copied to special vectors
   // including ghost values (see the relevant section in step-40). If we
   // wanted to access all degrees of freedom on ghost cells, too (e.g. when
@@ -556,7 +556,7 @@ namespace Step48
                               old_solution);
     output_results (0);
 
-    std::vector<parallel::distributed::Vector<double>*> previous_solutions;
+    std::vector<LinearAlgebra::distributed::Vector<double>*> previous_solutions;
     previous_solutions.push_back(&old_solution);
     previous_solutions.push_back(&old_old_solution);
 
index 9884463502cefe3e6dddc0cf80c69284ba5b8daf..135253b2fcd0f41499af240774108055824c6c1d 100644 (file)
@@ -814,7 +814,7 @@ public:
    * The reason this function exists is that this operation involves less
    * memory transfer than calling the two functions separately on deal.II's
    * vector classes (Vector<Number> and
-   * parallel::distributed::Vector<double>). This method only needs to load
+   * LinearAlgebra::distributed::Vector<double>). This method only needs to load
    * three vectors, @p this, @p V, @p W, whereas calling separate methods
    * means to load the calling vector @p this twice. Since most vector
    * operations are memory transfer limited, this reduces the time by 25\% (or
index bf2ee1b0f5cd3f340fa5ea4646ef66006fd56214..4d9da589f85a8d6408243e51b25ae30a66b6de12 100644 (file)
@@ -26,8 +26,8 @@
 #include <deal.II/lac/sparse_matrix.h>
 #include <deal.II/lac/block_sparsity_pattern.h>
 #include <deal.II/lac/block_sparse_matrix.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
@@ -532,7 +532,7 @@ namespace internal
       }
 
       template<typename Number>
-      void set_zero_parallel(const std::vector<size_type> &cm, parallel::distributed::Vector<Number> &vec, size_type shift = 0)
+      void set_zero_parallel(const std::vector<size_type> &cm, LinearAlgebra::distributed::Vector<Number> &vec, size_type shift = 0)
       {
         for (typename std::vector<size_type>::const_iterator it = cm.begin();
              it != cm.end(); ++it)
@@ -777,15 +777,15 @@ namespace internal
 
     template <typename number>
     void
-    import_vector_with_ghost_elements (const parallel::distributed::Vector<number> &vec,
+    import_vector_with_ghost_elements (const LinearAlgebra::distributed::Vector<number> &vec,
                                        const IndexSet                              &locally_owned_elements,
                                        const IndexSet                              &needed_elements,
-                                       parallel::distributed::Vector<number>       &output,
+                                       LinearAlgebra::distributed::Vector<number>       &output,
                                        const internal::bool2type<false>             /*is_block_vector*/)
     {
       // TODO: the in vector might already have all elements. need to find a
       // way to efficiently avoid the copy then
-      const_cast<parallel::distributed::Vector<number>&>(vec).zero_out_ghosts();
+      const_cast<LinearAlgebra::distributed::Vector<number>&>(vec).zero_out_ghosts();
       output.reinit (locally_owned_elements, needed_elements, vec.get_mpi_communicator());
       output = vec;
       output.update_ghost_values();
index 303d95ac2928d92922a253033802dd10c35efd1c..5f4b67250c67c16f21a508a0bd67ef34a45e1a2f 100644 (file)
@@ -25,7 +25,7 @@
 #  include <deal.II/base/std_cxx11/shared_ptr.h>
 
 #  include <deal.II/lac/trilinos_vector_base.h>
-#  include <deal.II/lac/parallel_vector.h>
+#  include <deal.II/lac/la_parallel_vector.h>
 
 DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
 #  ifdef DEAL_II_WITH_MPI
@@ -142,15 +142,15 @@ namespace TrilinosWrappers
      * Apply the preconditioner on deal.II parallel data structures instead of
      * the ones provided in the Trilinos wrapper class.
      */
-    virtual void vmult (dealii::parallel::distributed::Vector<double>       &dst,
-                        const dealii::parallel::distributed::Vector<double> &src) const;
+    virtual void vmult (dealii::LinearAlgebra::distributed::Vector<double>       &dst,
+                        const dealii::LinearAlgebra::distributed::Vector<double> &src) const;
 
     /**
      * Apply the transpose preconditioner on deal.II parallel data structures
      * instead of the ones provided in the Trilinos wrapper class.
      */
-    virtual void Tvmult (dealii::parallel::distributed::Vector<double>       &dst,
-                         const dealii::parallel::distributed::Vector<double> &src) const;
+    virtual void Tvmult (dealii::LinearAlgebra::distributed::Vector<double>       &dst,
+                         const dealii::LinearAlgebra::distributed::Vector<double> &src) const;
 
     /**
      * Return a reference to the underlaying Trilinos Epetra_Operator. So you
@@ -1834,16 +1834,16 @@ namespace TrilinosWrappers
      * Apply the preconditioner on deal.II parallel data structures instead of
      * the ones provided in the Trilinos wrapper class, i.e., dst = src.
      */
-    void vmult (parallel::distributed::Vector<double>       &dst,
-                const dealii::parallel::distributed::Vector<double> &src) const;
+    void vmult (LinearAlgebra::distributed::Vector<double>       &dst,
+                const dealii::LinearAlgebra::distributed::Vector<double> &src) const;
 
     /**
      * Apply the transpose preconditioner on deal.II parallel data structures
      * instead of the ones provided in the Trilinos wrapper class, i.e., dst =
      * src.
      */
-    void Tvmult (parallel::distributed::Vector<double>       &dst,
-                 const dealii::parallel::distributed::Vector<double> &src) const;
+    void Tvmult (LinearAlgebra::distributed::Vector<double>       &dst,
+                 const dealii::LinearAlgebra::distributed::Vector<double> &src) const;
   };
 
 
@@ -1936,8 +1936,8 @@ namespace TrilinosWrappers
 
   inline
   void
-  PreconditionBase::vmult (parallel::distributed::Vector<double>       &dst,
-                           const parallel::distributed::Vector<double> &src) const
+  PreconditionBase::vmult (LinearAlgebra::distributed::Vector<double>       &dst,
+                           const LinearAlgebra::distributed::Vector<double> &src) const
   {
     AssertDimension (static_cast<TrilinosWrappers::types::int_type>(dst.local_size()),
                      preconditioner->OperatorDomainMap().NumMyElements());
@@ -1954,8 +1954,8 @@ namespace TrilinosWrappers
 
   inline
   void
-  PreconditionBase::Tvmult (parallel::distributed::Vector<double>       &dst,
-                            const parallel::distributed::Vector<double> &src) const
+  PreconditionBase::Tvmult (LinearAlgebra::distributed::Vector<double>       &dst,
+                            const LinearAlgebra::distributed::Vector<double> &src) const
   {
     AssertDimension (static_cast<TrilinosWrappers::types::int_type>(dst.local_size()),
                      preconditioner->OperatorDomainMap().NumMyElements());
index 084bf77a41a845889a8d88f6f9b8f58f88e54ab2..04c07684ea28c8cfe5c47e720ec05579df556193 100644 (file)
@@ -25,7 +25,7 @@
 #  include <deal.II/lac/exceptions.h>
 #  include <deal.II/lac/solver_control.h>
 #  include <deal.II/lac/vector.h>
-#  include <deal.II/lac/parallel_vector.h>
+#  include <deal.II/lac/la_parallel_vector.h>
 
 DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
 #  include <Epetra_LinearProblem.h>
@@ -188,8 +188,8 @@ namespace TrilinosWrappers
      */
     void
     solve (const SparseMatrix                                  &A,
-           dealii::parallel::distributed::Vector<double>       &x,
-           const dealii::parallel::distributed::Vector<double> &b,
+           dealii::LinearAlgebra::distributed::Vector<double>       &x,
+           const dealii::LinearAlgebra::distributed::Vector<double> &b,
            const PreconditionBase                              &preconditioner);
 
     /**
@@ -201,8 +201,8 @@ namespace TrilinosWrappers
      */
     void
     solve (Epetra_Operator                                     &A,
-           dealii::parallel::distributed::Vector<double>       &x,
-           const dealii::parallel::distributed::Vector<double> &b,
+           dealii::LinearAlgebra::distributed::Vector<double>       &x,
+           const dealii::LinearAlgebra::distributed::Vector<double> &b,
            const PreconditionBase                              &preconditioner);
 
 
@@ -613,8 +613,8 @@ namespace TrilinosWrappers
      */
     void
     solve (const SparseMatrix                                  &A,
-           dealii::parallel::distributed::Vector<double>       &x,
-           const dealii::parallel::distributed::Vector<double> &b);
+           dealii::LinearAlgebra::distributed::Vector<double>       &x,
+           const dealii::LinearAlgebra::distributed::Vector<double> &b);
 
     /**
      * Access to object that controls convergence.
index 4b0c73e64d90a258d941e1dcd484ee95c27dcb63..8c6a324801c4c550e629f8a1dcad28ab42d0ded6 100644 (file)
@@ -1468,7 +1468,7 @@ namespace TrilinosWrappers
      * This function can be called with several different vector objects,
      * namely TrilinosWrappers::Vector, TrilinosWrappers::MPI::Vector as well
      * as deal.II's own vector classes Vector<double> and
-     * parallel::distributed::Vector<double>.
+     * LinearAlgebra::distributed::Vector<double>.
      *
      * Note that both vectors have to be distributed vectors generated using
      * the same Map as was used for the matrix in case you work on a
@@ -1494,7 +1494,7 @@ namespace TrilinosWrappers
      * This function can be called with several different vector objects,
      * namely TrilinosWrappers::Vector, TrilinosWrappers::MPI::Vector as well
      * as deal.II's own vector classes Vector<double> and
-     * parallel::distributed::Vector<double>.
+     * LinearAlgebra::distributed::Vector<double>.
      *
      * Note that both vectors have to be distributed vectors generated using
      * the same Map as was used for the matrix in case you work on a
@@ -1519,7 +1519,7 @@ namespace TrilinosWrappers
      * This function can be called with several different vector objects,
      * namely TrilinosWrappers::Vector, TrilinosWrappers::MPI::Vector as well
      * as deal.II's own vector classes Vector<double> and
-     * parallel::distributed::Vector<double>.
+     * LinearAlgebra::distributed::Vector<double>.
      *
      * When using a vector of type TrilinosWrappers::MPI::Vector, both vectors
      * have to be distributed vectors generated using the same Map as was used
@@ -1547,7 +1547,7 @@ namespace TrilinosWrappers
      * This function can be called with several different vector objects,
      * namely TrilinosWrappers::Vector, TrilinosWrappers::MPI::Vector as well
      * as deal.II's own vector classes Vector<double> and
-     * parallel::distributed::Vector<double>.
+     * LinearAlgebra::distributed::Vector<double>.
      *
      * When using a vector of type TrilinosWrappers::MPI::Vector, both vectors
      * have to be distributed vectors generated using the same Map as was used
index eec524e6f62e06aaf5f3062f00be17c11e7d873c..6ebcf604744704d7e818152d8cb9173eb6dc6ca0 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/fe/mapping.h>
 #include <deal.II/fe/mapping_q1.h>
 #include <deal.II/lac/vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/block_vector_base.h>
 #include <deal.II/lac/constraint_matrix.h>
 #include <deal.II/dofs/dof_handler.h>
@@ -506,7 +506,7 @@ public:
   /**
    * Initialize function for a general vector. The length of the vector is
    * equal to the total number of degrees in the DoFHandler. If the vector is
-   * of class parallel::distributed::Vector@<Number@>, the ghost entries are
+   * of class LinearAlgebra::distributed::Vector@<Number@>, the ghost entries are
    * set accordingly. For vector-valued problems with several DoFHandlers
    * underlying this class, the parameter @p vector_component defines which
    * component is to be used.
@@ -518,13 +518,13 @@ public:
   /**
    * Initialize function for a distributed vector. The length of the vector is
    * equal to the total number of degrees in the DoFHandler. If the vector is
-   * of class parallel::distributed::Vector@<Number@>, the ghost entries are
+   * of class LinearAlgebra::distributed::Vector@<Number@>, the ghost entries are
    * set accordingly. For vector-valued problems with several DoFHandlers
    * underlying this class, the parameter @p vector_component defines which
    * component is to be used.
    */
   template <typename Number2>
-  void initialize_dof_vector(parallel::distributed::Vector<Number2> &vec,
+  void initialize_dof_vector(LinearAlgebra::distributed::Vector<Number2> &vec,
                              const unsigned int vector_component=0) const;
 
   /**
@@ -953,7 +953,7 @@ template <int dim, typename Number>
 template <typename Number2>
 inline
 void
-MatrixFree<dim,Number>::initialize_dof_vector(parallel::distributed::Vector<Number2> &vec,
+MatrixFree<dim,Number>::initialize_dof_vector(LinearAlgebra::distributed::Vector<Number2> &vec,
                                               const unsigned int comp) const
 {
   AssertIndexRange (comp, n_components());
@@ -1685,7 +1685,7 @@ namespace internal
 
   template<typename Number>
   inline
-  bool update_ghost_values_start (const parallel::distributed::Vector<Number> &vec,
+  bool update_ghost_values_start (const LinearAlgebra::distributed::Vector<Number> &vec,
                                   const unsigned int                  channel = 0)
   {
     bool return_value = !vec.has_ghost_elements();
@@ -1749,11 +1749,11 @@ namespace internal
 
   template<typename Number>
   inline
-  void reset_ghost_values (const parallel::distributed::Vector<Number> &vec,
+  void reset_ghost_values (const LinearAlgebra::distributed::Vector<Number> &vec,
                            const bool zero_out_ghosts)
   {
     if (zero_out_ghosts)
-      const_cast<parallel::distributed::Vector<Number>&>(vec).zero_out_ghosts();
+      const_cast<LinearAlgebra::distributed::Vector<Number>&>(vec).zero_out_ghosts();
   }
 
 
@@ -1804,7 +1804,7 @@ namespace internal
 
   template <typename Number>
   inline
-  void update_ghost_values_finish (const parallel::distributed::Vector<Number> &vec)
+  void update_ghost_values_finish (const LinearAlgebra::distributed::Vector<Number> &vec)
   {
     vec.update_ghost_values_finish();
   }
@@ -1855,7 +1855,7 @@ namespace internal
 
   template <typename Number>
   inline
-  void compress_start (parallel::distributed::Vector<Number> &vec,
+  void compress_start (LinearAlgebra::distributed::Vector<Number> &vec,
                        const unsigned int           channel = 0)
   {
     vec.compress_start(channel);
@@ -1907,7 +1907,7 @@ namespace internal
 
   template <typename Number>
   inline
-  void compress_finish (parallel::distributed::Vector<Number> &vec)
+  void compress_finish (LinearAlgebra::distributed::Vector<Number> &vec)
   {
     vec.compress_finish(::dealii::VectorOperation::add);
   }
index 4f44a5cc1280af3d094476cbaf82c2dd696146c6..4712d6fe55fcc9c2677fb5d94aa6b956437daa37 100644 (file)
@@ -23,7 +23,7 @@
 #include <deal.II/lac/sparse_matrix.h>
 #include <deal.II/lac/block_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_sparse_matrix.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 
 #include <deal.II/lac/vector_memory.h>
 
@@ -58,7 +58,7 @@ namespace internal
 
 #ifdef DEAL_II_WITH_TRILINOS
   template <typename Number>
-  struct MatrixSelector<parallel::distributed::Vector<Number> >
+  struct MatrixSelector<LinearAlgebra::distributed::Vector<Number> >
   {
     typedef ::dealii::TrilinosWrappers::SparsityPattern Sparsity;
     typedef ::dealii::TrilinosWrappers::SparseMatrix Matrix;
@@ -259,7 +259,7 @@ protected:
  * Implementation of transfer between the global vectors and the multigrid
  * levels for use in the derived class MGTransferPrebuilt and other classes.
  * This class is a specialization for the case of
- * parallel::distributed::Vector that requires a few different calling
+ * LinearAlgebra::distributed::Vector that requires a few different calling
  * routines as compared to the %parallel vectors in the PETScWrappers and
  * TrilinosWrappers namespaces.
  *
@@ -267,7 +267,7 @@ protected:
  * @date 2016
  */
 template <typename Number>
-class MGLevelGlobalTransfer<parallel::distributed::Vector<Number> > : public MGTransferBase<parallel::distributed::Vector<Number> >
+class MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> > : public MGTransferBase<LinearAlgebra::distributed::Vector<Number> >
 {
 public:
 
@@ -283,8 +283,8 @@ public:
   template <int dim, typename Number2, int spacedim>
   void
   copy_to_mg (const DoFHandler<dim,spacedim>                        &mg_dof,
-              MGLevelObject<parallel::distributed::Vector<Number> > &dst,
-              const parallel::distributed::Vector<Number2>          &src) const;
+              MGLevelObject<LinearAlgebra::distributed::Vector<Number> > &dst,
+              const LinearAlgebra::distributed::Vector<Number2>          &src) const;
 
   /**
    * Transfer from multi-level vector to normal vector.
@@ -296,8 +296,8 @@ public:
   template <int dim, typename Number2, int spacedim>
   void
   copy_from_mg (const DoFHandler<dim,spacedim>                              &mg_dof,
-                parallel::distributed::Vector<Number2>                      &dst,
-                const MGLevelObject<parallel::distributed::Vector<Number> > &src) const;
+                LinearAlgebra::distributed::Vector<Number2>                      &dst,
+                const MGLevelObject<LinearAlgebra::distributed::Vector<Number> > &src) const;
 
   /**
    * Add a multi-level vector to a normal vector.
@@ -307,8 +307,8 @@ public:
   template <int dim, typename Number2, int spacedim>
   void
   copy_from_mg_add (const DoFHandler<dim,spacedim>                              &mg_dof,
-                    parallel::distributed::Vector<Number2>                      &dst,
-                    const MGLevelObject<parallel::distributed::Vector<Number> > &src) const;
+                    LinearAlgebra::distributed::Vector<Number2>                      &dst,
+                    const MGLevelObject<LinearAlgebra::distributed::Vector<Number> > &src) const;
 
   /**
    * If this object operates on BlockVector objects, we need to describe how
@@ -398,20 +398,20 @@ protected:
   /**
    * The mg_constrained_dofs of the level systems.
    */
-  SmartPointer<const MGConstrainedDoFs, MGLevelGlobalTransfer<parallel::distributed::Vector<Number> > > mg_constrained_dofs;
+  SmartPointer<const MGConstrainedDoFs, MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> > > mg_constrained_dofs;
 
   /**
    * In the function copy_to_mg, we need to access ghosted entries of the
    * global vector for inserting into the level vectors. This vector is
    * populated with those entries.
    */
-  mutable parallel::distributed::Vector<Number> ghosted_global_vector;
+  mutable LinearAlgebra::distributed::Vector<Number> ghosted_global_vector;
 
   /**
    * In the function copy_from_mg, we access all level vectors with certain
    * ghost entries for inserting the result into a global vector.
    */
-  mutable MGLevelObject<parallel::distributed::Vector<Number> > ghosted_level_vector;
+  mutable MGLevelObject<LinearAlgebra::distributed::Vector<Number> > ghosted_level_vector;
 };
 
 
index ead4d5e5961b382f357f40fabbf510ece4f23e65..2555013d394e5ce3df3b4216d6a41f68298c734e 100644 (file)
@@ -108,7 +108,7 @@ namespace
   void
   reinit_vector (const dealii::DoFHandler<dim,spacedim> &mg_dof,
                  const std::vector<unsigned int> &,
-                 MGLevelObject<parallel::distributed::Vector<number> > &v)
+                 MGLevelObject<LinearAlgebra::distributed::Vector<number> > &v)
   {
     const parallel::Triangulation<dim,spacedim> *tria =
       (dynamic_cast<const parallel::Triangulation<dim,spacedim>*>
@@ -368,15 +368,15 @@ set_component_to_block_map (const std::vector<unsigned int> &map)
 
 
 
-/* --------- MGLevelGlobalTransfer<parallel::distributed::Vector> ------- */
+/* --------- MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector> ------- */
 
 template <typename Number>
 template <int dim, typename Number2, int spacedim>
 void
-MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_to_mg
+MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::copy_to_mg
 (const DoFHandler<dim,spacedim>                        &mg_dof_handler,
- MGLevelObject<parallel::distributed::Vector<Number> > &dst,
- const parallel::distributed::Vector<Number2>          &src) const
+ MGLevelObject<LinearAlgebra::distributed::Vector<Number> > &dst,
+ const LinearAlgebra::distributed::Vector<Number2>          &src) const
 {
   AssertIndexRange(dst.max_level(), mg_dof_handler.get_triangulation().n_global_levels());
   AssertIndexRange(dst.min_level(), dst.max_level()+1);
@@ -415,7 +415,7 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_to_mg
       --level;
 
       typedef std::vector<std::pair<unsigned int, unsigned int> >::const_iterator dof_pair_iterator;
-      parallel::distributed::Vector<Number> &dst_level = dst[level];
+      LinearAlgebra::distributed::Vector<Number> &dst_level = dst[level];
 
       // first copy local unknowns
       for (dof_pair_iterator i = copy_indices[level].begin();
@@ -444,10 +444,10 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_to_mg
 template <typename Number>
 template <int dim, typename Number2, int spacedim>
 void
-MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_from_mg
+MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::copy_from_mg
 (const DoFHandler<dim,spacedim>                              &mg_dof_handler,
parallel::distributed::Vector<Number2>                      &dst,
- const MGLevelObject<parallel::distributed::Vector<Number> > &src) const
LinearAlgebra::distributed::Vector<Number2>                      &dst,
+ const MGLevelObject<LinearAlgebra::distributed::Vector<Number> > &src) const
 {
   (void)mg_dof_handler;
   AssertIndexRange(src.max_level(), mg_dof_handler.get_triangulation().n_global_levels());
@@ -481,7 +481,7 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_from_mg
 
       // the first time around, we copy the source vector to the temporary
       // vector that we hold for the purpose of data exchange
-      parallel::distributed::Vector<Number> &ghosted_vector =
+      LinearAlgebra::distributed::Vector<Number> &ghosted_vector =
         ghosted_level_vector[level];
       ghosted_vector = src[level];
       ghosted_vector.update_ghost_values();
@@ -505,10 +505,10 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_from_mg
 template <typename Number>
 template <int dim, typename Number2, int spacedim>
 void
-MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_from_mg_add
+MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::copy_from_mg_add
 (const DoFHandler<dim,spacedim>                              &/*mg_dof_handler*/,
parallel::distributed::Vector<Number2>                      &dst,
- const MGLevelObject<parallel::distributed::Vector<Number> > &src) const
LinearAlgebra::distributed::Vector<Number2>                      &dst,
+ const MGLevelObject<LinearAlgebra::distributed::Vector<Number> > &src) const
 {
   // For non-DG: degrees of freedom in the refinement face may need special
   // attention, since they belong to the coarse level, but have fine level
@@ -526,7 +526,7 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_from_mg_add
 
       // the first time around, we copy the source vector to the temporary
       // vector that we hold for the purpose of data exchange
-      parallel::distributed::Vector<Number> &ghosted_vector =
+      LinearAlgebra::distributed::Vector<Number> &ghosted_vector =
         ghosted_level_vector[level];
       ghosted_vector = src[level];
       ghosted_vector.update_ghost_values();
@@ -549,7 +549,7 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::copy_from_mg_add
 
 template <typename Number>
 void
-MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::
+MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::
 set_component_to_block_map (const std::vector<unsigned int> &map)
 {
   component_to_block_map = map;
index a56fd061ef2694c6df563665a7cdcc4dbe856c1c..86d39cc0af218f9ccc7eb046abbecde4c6d3f146 100644 (file)
@@ -18,7 +18,7 @@
 
 #include <deal.II/base/config.h>
 
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/multigrid/mg_base.h>
 #include <deal.II/multigrid/mg_constrained_dofs.h>
 #include <deal.II/base/mg_level_object.h>
@@ -50,7 +50,7 @@ DEAL_II_NAMESPACE_OPEN
  * @date 2016
  */
 template <int dim, typename Number>
-class MGTransferMatrixFree : public MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >
+class MGTransferMatrixFree : public MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >
 {
 public:
   /**
@@ -97,8 +97,8 @@ public:
    * finer level.
    */
   virtual void prolongate (const unsigned int                           to_level,
-                           parallel::distributed::Vector<Number>       &dst,
-                           const parallel::distributed::Vector<Number> &src) const;
+                           LinearAlgebra::distributed::Vector<Number>       &dst,
+                           const LinearAlgebra::distributed::Vector<Number> &src) const;
 
   /**
    * Restrict a vector from level <tt>from_level</tt> to level
@@ -116,8 +116,8 @@ public:
    * coarser level.
    */
   virtual void restrict_and_add (const unsigned int from_level,
-                                 parallel::distributed::Vector<Number>       &dst,
-                                 const parallel::distributed::Vector<Number> &src) const;
+                                 LinearAlgebra::distributed::Vector<Number>       &dst,
+                                 const LinearAlgebra::distributed::Vector<Number> &src) const;
 
   /**
    * Finite element does not provide prolongation matrices.
@@ -216,16 +216,16 @@ private:
    */
   template <int degree>
   void do_prolongate_add(const unsigned int                           to_level,
-                         parallel::distributed::Vector<Number>       &dst,
-                         const parallel::distributed::Vector<Number> &src) const;
+                         LinearAlgebra::distributed::Vector<Number>       &dst,
+                         const LinearAlgebra::distributed::Vector<Number> &src) const;
 
   /**
    * Performs templated restriction operation
    */
   template <int degree>
   void do_restrict_add(const unsigned int                           from_level,
-                       parallel::distributed::Vector<Number>       &dst,
-                       const parallel::distributed::Vector<Number> &src) const;
+                       LinearAlgebra::distributed::Vector<Number>       &dst,
+                       const LinearAlgebra::distributed::Vector<Number> &src) const;
 };
 
 
index c94dbad4d63cb707dc8e5b0e13ddb02525ed6fd2..3bb11b7d2011f41a81cb0ac068b7dbb37944f76d 100644 (file)
@@ -19,9 +19,9 @@
 #include <deal.II/base/quadrature_lib.h>
 #include <deal.II/base/work_stream.h>
 #include <deal.II/lac/vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index f5c046b61c2f82eee8406a637b98ef5000abaf0e..cfe4a5756c8cb637ffc4326ac5489162938c52bc 100644 (file)
@@ -23,8 +23,8 @@
 #include <deal.II/base/qprojector.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 475f6ea1f664d713ed97a2221f679af58d8793bc..c147f2331c449329df8b5d53f158e77436f2e09c 100644 (file)
@@ -24,8 +24,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index b9825a379acba13044f8ed433e5b7723affc726f..e78b50806fe33cec094ab3fac7bb40f8ad674234 100644 (file)
@@ -19,8 +19,8 @@
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/exceptions.h>
 #include <deal.II/lac/vector_memory.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/base/multithread_info.h>
 
 #include <iostream>
@@ -439,13 +439,13 @@ namespace Utilities
 #ifdef DEAL_II_WITH_MPI
       // Start with the deal.II MPI vectors (need to do this before finalizing
       // PETSc because it finalizes MPI).  Delete vectors from the pools:
-      GrowingVectorMemory<parallel::distributed::Vector<double> >
+      GrowingVectorMemory<LinearAlgebra::distributed::Vector<double> >
       ::release_unused_memory ();
-      GrowingVectorMemory<parallel::distributed::BlockVector<double> >
+      GrowingVectorMemory<LinearAlgebra::distributed::BlockVector<double> >
       ::release_unused_memory ();
-      GrowingVectorMemory<parallel::distributed::Vector<float> >
+      GrowingVectorMemory<LinearAlgebra::distributed::Vector<float> >
       ::release_unused_memory ();
-      GrowingVectorMemory<parallel::distributed::BlockVector<float> >
+      GrowingVectorMemory<LinearAlgebra::distributed::BlockVector<float> >
       ::release_unused_memory ();
 
       // Next with Trilinos:
index a75b30b586bd02d480664938fb92ca9780441adf..cc8648986188c0ac178862407014a7c45048328e 100644 (file)
@@ -16,8 +16,8 @@
 #include <deal.II/base/time_stepping.templates.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
index 29d71738ecadad7c0b019ed1adae2e6b73acce41..f9da377ef9fba8d40ed480e61db2ae41d06519e8 100644 (file)
@@ -24,10 +24,10 @@ for (S : REAL_SCALARS; V : DEAL_II_VEC_TEMPLATES)
 
 for (S : REAL_SCALARS; V : DEAL_II_VEC_TEMPLATES)
 {
-  template class RungeKutta<parallel::distributed::V<S> >;
-  template class ExplicitRungeKutta<parallel::distributed::V<S> >;
-  template class ImplicitRungeKutta<parallel::distributed::V<S> >;
-  template class EmbeddedExplicitRungeKutta<parallel::distributed::V<S> >;
+  template class RungeKutta<LinearAlgebra::distributed::V<S> >;
+  template class ExplicitRungeKutta<LinearAlgebra::distributed::V<S> >;
+  template class ImplicitRungeKutta<LinearAlgebra::distributed::V<S> >;
+  template class EmbeddedExplicitRungeKutta<LinearAlgebra::distributed::V<S> >;
 }
 
 for (V : EXTERNAL_SEQUENTIAL_VECTORS)
index 8abc708ae021d2c922e9ac1a53269a6d226ea5b0..4713e5593af55d5eea69a64c45dea93285f4516f 100644 (file)
@@ -20,8 +20,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 248a52a59090c4edca9b9bf3b175af3d263840d0..a5cc1a5fefb57996135aa16a2ef3620baef06cc7 100644 (file)
@@ -24,10 +24,10 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
 #if deal_II_dimension > 1
 #if deal_II_dimension <= deal_II_space_dimension
     template class SolutionTransfer<deal_II_dimension,::dealii::Vector<double>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
-    template class SolutionTransfer<deal_II_dimension,::dealii::parallel::distributed::Vector<double>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
-    template class SolutionTransfer<deal_II_dimension,::dealii::parallel::distributed::Vector<float>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
-    template class SolutionTransfer<deal_II_dimension,::dealii::parallel::distributed::BlockVector<double>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
-    template class SolutionTransfer<deal_II_dimension,::dealii::parallel::distributed::BlockVector<float>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
+    template class SolutionTransfer<deal_II_dimension,::dealii::LinearAlgebra::distributed::Vector<double>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
+    template class SolutionTransfer<deal_II_dimension,::dealii::LinearAlgebra::distributed::Vector<float>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
+    template class SolutionTransfer<deal_II_dimension,::dealii::LinearAlgebra::distributed::BlockVector<double>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
+    template class SolutionTransfer<deal_II_dimension,::dealii::LinearAlgebra::distributed::BlockVector<float>, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
 
 
 #ifdef DEAL_II_WITH_PETSC
@@ -49,11 +49,10 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
 
     template class SolutionTransfer<deal_II_dimension, TrilinosWrappers::MPI::BlockVector, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
 #endif
-    
+
 #endif
 #endif
     \}
   \}
 
   }
-
index b8a77812c88c58d8b67d7f36ea651dd31fb1069a..2bc7ebe4bd8a12dc802e29612f6ad68c9b53d178 100644 (file)
@@ -15,8 +15,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index a97193cfe81cb4abc0a60805ab86be165c5178ad..1748a5ffcf39ed43e7932af1cdae6338e5377b76 100644 (file)
@@ -15,8 +15,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 8531af2a56808661265de13e779affc31ccab9cd..8cb4a96b87724ae2228d8d99007a6a34ee6a0eb0 100644 (file)
@@ -35,7 +35,7 @@
 #include <deal.II/dofs/dof_tools.h>
 
 #ifdef DEAL_II_WITH_MPI
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #endif
 
 #include <algorithm>
@@ -2504,7 +2504,7 @@ namespace DoFTools
         unsigned int                         dofs_per_cell;
         std::vector<types::global_dof_index> parameter_dof_indices;
 #ifdef DEAL_II_WITH_MPI
-        std::vector<dealii::parallel::distributed::Vector<double> > global_parameter_representation;
+        std::vector<dealii::LinearAlgebra::distributed::Vector<double> > global_parameter_representation;
 #else
         std::vector<dealii::Vector<double> > global_parameter_representation;
 #endif
index 5d5c68c3d4ea3836c118dc4074a2eaf03b84ec40..f95e4e2a05ddcac39e6976a8e089a12addbc5031 100644 (file)
@@ -20,8 +20,8 @@
 #include <deal.II/base/utilities.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/petsc_parallel_block_vector.h>
@@ -471,21 +471,21 @@ namespace FETools
       }
 #endif
 
-      // special version for parallel::distributed::Vector
+      // special version for LinearAlgebra::distributed::Vector
       template <int dim, int spacedim, typename Number>
       void back_interpolate (const DoFHandler<dim,spacedim> &dof1,
                              const ConstraintMatrix &constraints1,
-                             const parallel::distributed::Vector<Number> &u1,
+                             const LinearAlgebra::distributed::Vector<Number> &u1,
                              const DoFHandler<dim,spacedim> &dof2,
                              const ConstraintMatrix &constraints2,
-                             parallel::distributed::Vector<Number> &u1_interpolated)
+                             LinearAlgebra::distributed::Vector<Number> &u1_interpolated)
       {
         IndexSet dof2_locally_owned_dofs = dof2.locally_owned_dofs();
         IndexSet dof2_locally_relevant_dofs;
         DoFTools::extract_locally_relevant_dofs (dof2,
                                                  dof2_locally_relevant_dofs);
 
-        parallel::distributed::Vector<Number>
+        LinearAlgebra::distributed::Vector<Number>
         u2 (dof2_locally_owned_dofs,
             dof2_locally_relevant_dofs,
             u1.get_mpi_communicator());
index 4392910aea41c75552aec34a0338bfa5a1f664b8..5274b76bf931552794c60cf3175055a42dd3d0e0 100644 (file)
@@ -20,8 +20,8 @@
 #include <deal.II/base/std_cxx11/unique_ptr.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 2ed652a1c5973b059ca3acc83aed50980cd5d710..6a5f5a3af1f928999b6913c45d3063ed9eefe065 100644 (file)
@@ -23,8 +23,8 @@
 #include <deal.II/lac/sparse_matrix_ez.h>
 #include <deal.II/lac/chunk_sparse_matrix.h>
 #include <deal.II/lac/block_sparse_matrix_ez.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/petsc_sparse_matrix.h>
index 5010a6f75c68b71807f998e0926fd9940fcc7990..3fd397a5dd54f3ef6f6b48066ae0c25bc5fbefdf 100644 (file)
@@ -18,7 +18,7 @@ for (S: REAL_SCALARS; T : DEAL_II_VEC_TEMPLATES)
     template void ConstraintMatrix::condense<T<S> >(const T<S> &, T<S> &) const;
     template void ConstraintMatrix::condense<T<S> >(T<S> &vec) const;
     template void ConstraintMatrix::distribute_local_to_global<T<S> > (
-      const Vector<S>&, const std::vector<types::global_dof_index> &, T<S> &, const FullMatrix<S>&) const;  
+      const Vector<S>&, const std::vector<types::global_dof_index> &, T<S> &, const FullMatrix<S>&) const;
     template void ConstraintMatrix::distribute_local_to_global<T<S> > (
       const Vector<S>&, const std::vector<types::global_dof_index> &, const std::vector<types::global_dof_index> &, T<S> &, const FullMatrix<S>&, bool) const;
     template void ConstraintMatrix::set_zero<T<S> >(T<S> &) const;
@@ -27,13 +27,13 @@ for (S: REAL_SCALARS; T : DEAL_II_VEC_TEMPLATES)
 
 for (S: REAL_SCALARS; T : DEAL_II_VEC_TEMPLATES)
   {
-    template void ConstraintMatrix::condense<parallel::distributed::T<S> >(const parallel::distributed::T<S> &, parallel::distributed::T<S> &) const;
-    template void ConstraintMatrix::condense<parallel::distributed::T<S> >(parallel::distributed::T<S> &vec) const;
-    template void ConstraintMatrix::distribute_local_to_global<parallel::distributed::T<S> > (
-      const Vector<S>&, const std::vector<types::global_dof_index> &, parallel::distributed::T<S> &, const FullMatrix<S>&) const;
-    template void ConstraintMatrix::distribute_local_to_global<parallel::distributed::T<S> > (
-      const Vector<S>&, const std::vector<types::global_dof_index> &, const std::vector<types::global_dof_index> &, parallel::distributed::T<S> &, const FullMatrix<S>&, bool) const;
-    template void ConstraintMatrix::set_zero<parallel::distributed::T<S> >(parallel::distributed::T<S> &) const;
+    template void ConstraintMatrix::condense<LinearAlgebra::distributed::T<S> >(const LinearAlgebra::distributed::T<S> &, LinearAlgebra::distributed::T<S> &) const;
+    template void ConstraintMatrix::condense<LinearAlgebra::distributed::T<S> >(LinearAlgebra::distributed::T<S> &vec) const;
+    template void ConstraintMatrix::distribute_local_to_global<LinearAlgebra::distributed::T<S> > (
+      const Vector<S>&, const std::vector<types::global_dof_index> &, LinearAlgebra::distributed::T<S> &, const FullMatrix<S>&) const;
+    template void ConstraintMatrix::distribute_local_to_global<LinearAlgebra::distributed::T<S> > (
+      const Vector<S>&, const std::vector<types::global_dof_index> &, const std::vector<types::global_dof_index> &, LinearAlgebra::distributed::T<S> &, const FullMatrix<S>&, bool) const;
+    template void ConstraintMatrix::set_zero<LinearAlgebra::distributed::T<S> >(LinearAlgebra::distributed::T<S> &) const;
   }
 
 
@@ -67,7 +67,7 @@ for (S1 : REAL_SCALARS; S2 : REAL_SCALARS)
     template void ConstraintMatrix::condense<S1,Vector<S2> >(SparseMatrix<S1>&, Vector<S2>&) const;
     template void ConstraintMatrix::condense<S1,BlockVector<S2> >(BlockSparseMatrix<S1>&, BlockVector<S2>&) const;
   }
-  
+
 for (S1 : COMPLEX_SCALARS)
   {
     template void ConstraintMatrix::condense<S1,Vector<S1> >(SparseMatrix<S1>&, Vector<S1>&) const;
@@ -78,9 +78,8 @@ for (Vec : SERIAL_VECTORS)
   {
     template void ConstraintMatrix::distribute<Vec>(Vec &) const;
   }
-  
+
 for (S: COMPLEX_SCALARS; T : DEAL_II_VEC_TEMPLATES)
   {
     template void ConstraintMatrix::distribute<T<S> >(T<S> &) const;
   }
-
index 2819e220fd753ac2178ac1eee5a0bdb9c0fb1465..d7d803fba8ff750afc831244853a461620f3f6fb 100644 (file)
@@ -23,8 +23,8 @@
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 
 DEAL_II_NAMESPACE_OPEN
 
index 21f590a2b52952f5cb4681c9026d210bc6f46a51..8a7d544652c3f4138a1fd41c0ff01a7140162a34 100644 (file)
@@ -15,7 +15,7 @@
 
 #include <deal.II/lac/sparse_matrix.templates.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 
 DEAL_II_NAMESPACE_OPEN
 
index dee0b31bf53ef6d933da58d6e8f596a9928704c1..010e8791f184dd40e0aab9e5cea08c14dc9fa42f 100644 (file)
@@ -140,13 +140,13 @@ for (S1, S2, S3 : REAL_SCALARS;
 for (S1 : REAL_SCALARS)
   {
     template void SparseMatrix<S1>::
-      vmult (parallel::distributed::Vector<S1> &, const parallel::distributed::Vector<S1> &) const;
+      vmult (LinearAlgebra::distributed::Vector<S1> &, const LinearAlgebra::distributed::Vector<S1> &) const;
     template void SparseMatrix<S1>::
-      Tvmult (parallel::distributed::Vector<S1> &, const parallel::distributed::Vector<S1> &) const;
+      Tvmult (LinearAlgebra::distributed::Vector<S1> &, const LinearAlgebra::distributed::Vector<S1> &) const;
     template void SparseMatrix<S1>::
-      vmult_add (parallel::distributed::Vector<S1> &, const parallel::distributed::Vector<S1> &) const;
+      vmult_add (LinearAlgebra::distributed::Vector<S1> &, const LinearAlgebra::distributed::Vector<S1> &) const;
     template void SparseMatrix<S1>::
-      Tvmult_add (parallel::distributed::Vector<S1> &, const parallel::distributed::Vector<S1> &) const;
+      Tvmult_add (LinearAlgebra::distributed::Vector<S1> &, const LinearAlgebra::distributed::Vector<S1> &) const;
   }
 
 for (S1, S2, S3: REAL_SCALARS)
index 2452756243576da605638f3cb42ffcb3c4fa1060..5ac1629a06dd17da6cf5f9262ab82d07fcea1368 100644 (file)
@@ -16,7 +16,7 @@
 
 #include <deal.II/lac/sparse_matrix.templates.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 
 DEAL_II_NAMESPACE_OPEN
 
index 09457ef9ab3e8f39d12135f19fa7369049e2ccfd..b15fe1e26520ec79eeaca243ae369df325c0d297 100644 (file)
@@ -703,15 +703,15 @@ namespace TrilinosWrappers
   }
 
   void
-  PreconditionIdentity::vmult(parallel::distributed::Vector<double>       &dst,
-                              const parallel::distributed::Vector<double> &src) const
+  PreconditionIdentity::vmult(LinearAlgebra::distributed::Vector<double>       &dst,
+                              const LinearAlgebra::distributed::Vector<double> &src) const
   {
     dst = src;
   }
 
   void
-  PreconditionIdentity::Tvmult(parallel::distributed::Vector<double>       &dst,
-                               const parallel::distributed::Vector<double> &src) const
+  PreconditionIdentity::Tvmult(LinearAlgebra::distributed::Vector<double>       &dst,
+                               const LinearAlgebra::distributed::Vector<double> &src) const
   {
     dst = src;
   }
index b28637bc5537cb2e42ea209c0e770fadf50a09ae..3c343844f78e9dc8a66629f53f4ea8f0668e5141 100644 (file)
@@ -163,8 +163,8 @@ namespace TrilinosWrappers
 
   void
   SolverBase::solve (const SparseMatrix                                  &A,
-                     dealii::parallel::distributed::Vector<double>       &x,
-                     const dealii::parallel::distributed::Vector<double> &b,
+                     dealii::LinearAlgebra::distributed::Vector<double>       &x,
+                     const dealii::LinearAlgebra::distributed::Vector<double> &b,
                      const PreconditionBase                              &preconditioner)
   {
     linear_problem.reset();
@@ -192,8 +192,8 @@ namespace TrilinosWrappers
 
   void
   SolverBase::solve (Epetra_Operator                                     &A,
-                     dealii::parallel::distributed::Vector<double>       &x,
-                     const dealii::parallel::distributed::Vector<double> &b,
+                     dealii::LinearAlgebra::distributed::Vector<double>       &x,
+                     const dealii::LinearAlgebra::distributed::Vector<double> &b,
                      const PreconditionBase                              &preconditioner)
   {
     linear_problem.reset();
@@ -616,8 +616,8 @@ namespace TrilinosWrappers
 
   void
   SolverDirect::solve (const SparseMatrix                                  &A,
-                       dealii::parallel::distributed::Vector<double>       &x,
-                       const dealii::parallel::distributed::Vector<double> &b)
+                       dealii::LinearAlgebra::distributed::Vector<double>       &x,
+                       const dealii::LinearAlgebra::distributed::Vector<double> &b)
   {
     AssertDimension (static_cast<TrilinosWrappers::types::int_type>(x.local_size()),
                      A.domain_partitioner().NumMyElements());
index b8e96e7a2a1f6079bb26f20a4bd0175ed707c7f0..9017181b30541cbd8baa3c8a4f7f10fa483704fe 100644 (file)
@@ -23,7 +23,7 @@
 #  include <deal.II/lac/sparsity_pattern.h>
 #  include <deal.II/lac/dynamic_sparsity_pattern.h>
 #  include <deal.II/lac/sparsity_tools.h>
-#  include <deal.II/lac/parallel_vector.h>
+#  include <deal.II/lac/la_parallel_vector.h>
 
 DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
 #  include <Epetra_Export.h>
@@ -2500,8 +2500,8 @@ namespace TrilinosWrappers
   SparseMatrix::vmult (dealii::Vector<double> &,
                        const dealii::Vector<double> &) const;
   template void
-  SparseMatrix::vmult (dealii::parallel::distributed::Vector<double> &,
-                       const dealii::parallel::distributed::Vector<double> &) const;
+  SparseMatrix::vmult (dealii::LinearAlgebra::distributed::Vector<double> &,
+                       const dealii::LinearAlgebra::distributed::Vector<double> &) const;
   template void
   SparseMatrix::Tvmult (VectorBase &,
                         const VectorBase &) const;
@@ -2515,8 +2515,8 @@ namespace TrilinosWrappers
   SparseMatrix::Tvmult (dealii::Vector<double> &,
                         const dealii::Vector<double> &) const;
   template void
-  SparseMatrix::Tvmult (dealii::parallel::distributed::Vector<double> &,
-                        const dealii::parallel::distributed::Vector<double> &) const;
+  SparseMatrix::Tvmult (dealii::LinearAlgebra::distributed::Vector<double> &,
+                        const dealii::LinearAlgebra::distributed::Vector<double> &) const;
   template void
   SparseMatrix::vmult_add (VectorBase &,
                            const VectorBase &) const;
@@ -2530,8 +2530,8 @@ namespace TrilinosWrappers
   SparseMatrix::vmult_add (dealii::Vector<double> &,
                            const dealii::Vector<double> &) const;
   template void
-  SparseMatrix::vmult_add (dealii::parallel::distributed::Vector<double> &,
-                           const dealii::parallel::distributed::Vector<double> &) const;
+  SparseMatrix::vmult_add (dealii::LinearAlgebra::distributed::Vector<double> &,
+                           const dealii::LinearAlgebra::distributed::Vector<double> &) const;
   template void
   SparseMatrix::Tvmult_add (VectorBase &,
                             const VectorBase &) const;
@@ -2545,8 +2545,8 @@ namespace TrilinosWrappers
   SparseMatrix::Tvmult_add (dealii::Vector<double> &,
                             const dealii::Vector<double> &) const;
   template void
-  SparseMatrix::Tvmult_add (dealii::parallel::distributed::Vector<double> &,
-                            const dealii::parallel::distributed::Vector<double> &) const;
+  SparseMatrix::Tvmult_add (dealii::LinearAlgebra::distributed::Vector<double> &,
+                            const dealii::LinearAlgebra::distributed::Vector<double> &) const;
 }
 
 DEAL_II_NAMESPACE_CLOSE
index 9e38ad9b3971d38add8bf8e7426067c915a2b32b..5330c0365e2458e4b09d02286b069dffb425936a 100644 (file)
@@ -15,8 +15,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
index b73025c81dee23a96b1089d8b347b19dab1856d5..111572ef517ca0fbee68c9d4ca1fa3fc30f5ab37 100644 (file)
@@ -16,8 +16,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index f2dd74ded2dac5b733190d86a4bfbc24ab2dda07..64c3f71cbc53e00bb49fc00affdc356f5fd32273 100644 (file)
@@ -15,8 +15,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 12c2ed4698ed8032a361efdb8e133e6b659f2f3d..a74eb04a7afb058fee403ff2c1c706a37148b647 100644 (file)
@@ -19,8 +19,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
@@ -385,7 +385,7 @@ MGLevelGlobalTransfer<VectorType>::memory_consumption () const
 template <typename Number>
 template <int dim, int spacedim>
 void
-MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::fill_and_communicate_copy_indices
+MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::fill_and_communicate_copy_indices
 (const DoFHandler<dim,spacedim> &mg_dof)
 {
   // first go to the usual routine...
@@ -516,7 +516,7 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::fill_and_communic
 
 template <typename Number>
 void
-MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::clear()
+MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::clear()
 {
   sizes.resize(0);
   copy_indices.clear();
@@ -532,7 +532,7 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::clear()
 
 template <typename Number>
 void
-MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::print_indices (std::ostream &os) const
+MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::print_indices (std::ostream &os) const
 {
   for (unsigned int level = 0; level<copy_indices.size(); ++level)
     {
@@ -559,7 +559,7 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::print_indices (st
 
 template <typename Number>
 std::size_t
-MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::memory_consumption () const
+MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::memory_consumption () const
 {
   std::size_t result = sizeof(*this);
   result += MemoryConsumption::memory_consumption(sizes);
@@ -581,7 +581,7 @@ MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::memory_consumptio
 
 // create an additional instantiation currently not supported by the automatic
 // template instantiation scheme
-template class MGLevelGlobalTransfer<parallel::distributed::Vector<float> >;
+template class MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<float> >;
 
 
 DEAL_II_NAMESPACE_CLOSE
index 4fee9d260e215480169c04f690f31ce63bc5b05b..908bb1b665fd627b1edb69affde7e521bcce9e1a 100644 (file)
@@ -43,21 +43,21 @@ for (deal_II_dimension : DIMENSIONS; V1,V2 : DEAL_II_VEC_TEMPLATES; S1, S2 : REA
 for (deal_II_dimension : DIMENSIONS)
   {
     template
-      void MGLevelGlobalTransfer< parallel::distributed::Vector<float> >::fill_and_communicate_copy_indices<deal_II_dimension,deal_II_dimension>(
+      void MGLevelGlobalTransfer< LinearAlgebra::distributed::Vector<float> >::fill_and_communicate_copy_indices<deal_II_dimension,deal_II_dimension>(
         const DoFHandler<deal_II_dimension,deal_II_dimension> &mg_dof);
   }
 
 for (deal_II_dimension : DIMENSIONS; S1, S2 : REAL_SCALARS)
   {
     template void
-      MGLevelGlobalTransfer<parallel::distributed::Vector<S1> >::copy_to_mg (
-        const DoFHandler<deal_II_dimension>&, MGLevelObject<parallel::distributed::Vector<S1> >&, const parallel::distributed::Vector<S2>&) const;
+      MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<S1> >::copy_to_mg (
+        const DoFHandler<deal_II_dimension>&, MGLevelObject<LinearAlgebra::distributed::Vector<S1> >&, const LinearAlgebra::distributed::Vector<S2>&) const;
     template void
-      MGLevelGlobalTransfer<parallel::distributed::Vector<S1> >::copy_from_mg (const DoFHandler<deal_II_dimension>&, parallel::distributed::Vector<S2>&,
-        const MGLevelObject<parallel::distributed::Vector<S1> >&) const;
+      MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<S1> >::copy_from_mg (const DoFHandler<deal_II_dimension>&, LinearAlgebra::distributed::Vector<S2>&,
+        const MGLevelObject<LinearAlgebra::distributed::Vector<S1> >&) const;
     template void
-      MGLevelGlobalTransfer<parallel::distributed::Vector<S1> >::copy_from_mg_add (const DoFHandler<deal_II_dimension>&, parallel::distributed::Vector<S2>&,
-        const MGLevelObject<parallel::distributed::Vector<S1> >&) const;
+      MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<S1> >::copy_from_mg_add (const DoFHandler<deal_II_dimension>&, LinearAlgebra::distributed::Vector<S2>&,
+        const MGLevelObject<LinearAlgebra::distributed::Vector<S1> >&) const;
   }
 
 for(deal_II_dimension : DIMENSIONS)
index 07efec30057e8d2269890457d663dcc008c1904a..3c727441cc80f4e7964069c78cf08e519918ca6b 100644 (file)
@@ -17,7 +17,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/function.h>
 
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/grid/tria.h>
 #include <deal.II/grid/tria_iterator.h>
 #include <deal.II/dofs/dof_tools.h>
@@ -77,7 +77,7 @@ void MGTransferMatrixFree<dim,Number>::initialize_constraints
 template <int dim, typename Number>
 void MGTransferMatrixFree<dim,Number>::clear ()
 {
-  this->MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::clear();
+  this->MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::clear();
   fe_degree = 0;
   element_is_continuous = false;
   n_components = 0;
@@ -164,7 +164,7 @@ namespace
   reinit_ghosted_vector(const IndexSet &locally_owned,
                         std::vector<types::global_dof_index> &ghosted_level_dofs,
                         const MPI_Comm &communicator,
-                        parallel::distributed::Vector<Number> &ghosted_level_vector,
+                        LinearAlgebra::distributed::Vector<Number> &ghosted_level_vector,
                         std::vector<std::pair<unsigned int,unsigned int> > &copy_indices_global_mine)
   {
     std::sort(ghosted_level_dofs.begin(), ghosted_level_dofs.end());
@@ -547,8 +547,8 @@ void MGTransferMatrixFree<dim,Number>::build
 template <int dim, typename Number>
 void MGTransferMatrixFree<dim,Number>
 ::prolongate (const unsigned int                           to_level,
-              parallel::distributed::Vector<Number>       &dst,
-              const parallel::distributed::Vector<Number> &src) const
+              LinearAlgebra::distributed::Vector<Number>       &dst,
+              const LinearAlgebra::distributed::Vector<Number> &src) const
 {
   Assert ((to_level >= 1) && (to_level<=level_dof_indices.size()),
           ExcIndexRange (to_level, 1, level_dof_indices.size()+1));
@@ -610,8 +610,8 @@ void MGTransferMatrixFree<dim,Number>
 template <int dim, typename Number>
 void MGTransferMatrixFree<dim,Number>
 ::restrict_and_add (const unsigned int                           from_level,
-                    parallel::distributed::Vector<Number>       &dst,
-                    const parallel::distributed::Vector<Number> &src) const
+                    LinearAlgebra::distributed::Vector<Number>       &dst,
+                    const LinearAlgebra::distributed::Vector<Number> &src) const
 {
   Assert ((from_level >= 1) && (from_level<=level_dof_indices.size()),
           ExcIndexRange (from_level, 1, level_dof_indices.size()+1));
@@ -747,8 +747,8 @@ template <int dim, typename Number>
 template <int degree>
 void MGTransferMatrixFree<dim,Number>
 ::do_prolongate_add (const unsigned int                           to_level,
-                     parallel::distributed::Vector<Number>       &dst,
-                     const parallel::distributed::Vector<Number> &src) const
+                     LinearAlgebra::distributed::Vector<Number>       &dst,
+                     const LinearAlgebra::distributed::Vector<Number> &src) const
 {
   const unsigned int vec_size = VectorizedArray<Number>::n_array_elements;
   const unsigned int n_child_dofs_1d = 2*(fe_degree+1) - element_is_continuous;
@@ -835,8 +835,8 @@ template <int dim, typename Number>
 template <int degree>
 void MGTransferMatrixFree<dim,Number>
 ::do_restrict_add (const unsigned int                           from_level,
-                   parallel::distributed::Vector<Number>       &dst,
-                   const parallel::distributed::Vector<Number> &src) const
+                   LinearAlgebra::distributed::Vector<Number>       &dst,
+                   const LinearAlgebra::distributed::Vector<Number> &src) const
 {
   const unsigned int vec_size = VectorizedArray<Number>::n_array_elements;
   const unsigned int n_child_dofs_1d = 2*(fe_degree+1) - element_is_continuous;
@@ -928,7 +928,7 @@ template <int dim, typename Number>
 std::size_t
 MGTransferMatrixFree<dim,Number>::memory_consumption() const
 {
-  std::size_t memory = MGLevelGlobalTransfer<parallel::distributed::Vector<Number> >::memory_consumption();
+  std::size_t memory = MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number> >::memory_consumption();
   memory += MemoryConsumption::memory_consumption(level_dof_indices);
   memory += MemoryConsumption::memory_consumption(parent_child_connect);
   memory += MemoryConsumption::memory_consumption(n_owned_level_cells);
index ec27b7f8d19eeb7bdfb39b723b5bb7ff04dcd13f..95c6d32a65126b48feccf2457844f6e4edcd8623 100644 (file)
@@ -19,8 +19,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 7d83ea17da129d101027f3225726c76abfa30b9f..33658dcee147d7e79734c3ebc8154a32f58ac54c 100644 (file)
@@ -15,8 +15,8 @@
 
 
 #include <deal.II/lac/vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 92a859dff4564ceaeab1cbf251d601b0871a2a64..7253049b44f6e984a419a3c759d7fc4f5980efdd 100644 (file)
@@ -18,8 +18,8 @@
 #include <deal.II/base/memory_consumption.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 055a71e985c7547579b8b7590dd19b66cb79a3cb..149010065190f97d9c132116c8de4db11ba18cb3 100644 (file)
@@ -17,8 +17,8 @@
 #include <deal.II/base/work_stream.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index c91b21b775d24947b2be3532f84bffc43f3fc089..ce11b428a6cde7f153f3c5de219c5830ff424649 100644 (file)
@@ -22,8 +22,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 788488570aa75facaea73f3bd4e31b93e9459373..88e335fcd942df5aa722996e2a3d350476de8dca 100644 (file)
@@ -18,9 +18,9 @@
 #include <deal.II/base/quadrature_lib.h>
 #include <deal.II/base/work_stream.h>
 #include <deal.II/lac/vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 12e2eec2c9be28efc05b99c8ddc6608e03124727..3117a90d8c7804992d4d61d87701cccf9bf38d96 100644 (file)
@@ -21,8 +21,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 3ef392f964de6bf717f7dafc072beead3e72bf96..21109d40ea05e2e9c523142faa9fb1be21d7973a 100644 (file)
@@ -16,8 +16,8 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 1419ce7a31d6b5335432cd390bc4c906db003956..6e1dc4def21fb2ea5d71477932eb78506f95da83 100644 (file)
 #include <deal.II/grid/tria_iterator.h>
 #include <deal.II/fe/fe.h>
 #include <deal.II/lac/vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/petsc_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/block_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/numerics/solution_transfer.h>
index 0ce140eb4233aaa9b870f554b115fe1136b7da70..46fc19ee24f10506d26a2f73d8a146e8c3b9164d 100644 (file)
@@ -16,7 +16,7 @@
 
 #include "../tests.h"
 #include "fe_tools_common.h"
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/sparsity_pattern.h>
 
 // check
@@ -56,9 +56,9 @@ check_this (const FiniteElement<dim> &fe1,
   cm1.close ();
   cm2.close ();
 
-  parallel::distributed::Vector<double> in (dof1->n_dofs());
+  LinearAlgebra::distributed::Vector<double> in (dof1->n_dofs());
   for (unsigned int i=0; i<in.size(); ++i) in(i) = i;
-  parallel::distributed::Vector<double> out (dof1->n_dofs());
+  LinearAlgebra::distributed::Vector<double> out (dof1->n_dofs());
 
   FETools::back_interpolate (*dof1, cm1, in, *dof2, cm2, out);
   output_vector (out);
index 926ea8559e892ae03472f274b980b7c9aad4c896..85b0ebdc5fd371f71e8c7df1491bf6986a41c0b9 100644 (file)
@@ -21,7 +21,7 @@
 #include "../tests.h"
 #include <deal.II/lac/generic_linear_algebra.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <fstream>
 #include <iostream>
 #include <iomanip>
@@ -87,9 +87,9 @@ int main (int argc, char **argv)
 
     {
       deallog.push("deal.II");
-      parallel::distributed::Vector<double> w(local, MPI_COMM_WORLD);
+      LinearAlgebra::distributed::Vector<double> w(local, MPI_COMM_WORLD);
       set (w);
-      parallel::distributed::Vector<double> v(local, dense_local, MPI_COMM_WORLD);
+      LinearAlgebra::distributed::Vector<double> v(local, dense_local, MPI_COMM_WORLD);
       v = w; // get copy of vector including ghost elements
       test (v);
       deallog.pop();
@@ -149,9 +149,9 @@ int main (int argc, char **argv)
 
     {
       deallog.push("deal.II");
-      parallel::distributed::BlockVector<double> w(partitioning, MPI_COMM_WORLD);
+      LinearAlgebra::distributed::BlockVector<double> w(partitioning, MPI_COMM_WORLD);
       set (w);
-      parallel::distributed::BlockVector<double> v(partitioning, dense_partitioning, MPI_COMM_WORLD);
+      LinearAlgebra::distributed::BlockVector<double> v(partitioning, dense_partitioning, MPI_COMM_WORLD);
       v = w; // get copy of vector including ghost elements
       test (v);
       deallog.pop();
index c34325ddbf9b11fc6f51ab6f2fcfd80c85a8461e..1bce780f728653e01b5623cc50e0ffc4b4d61779 100644 (file)
 // ---------------------------------------------------------------------
 
 
-// check that parallel::distributed::Vector::reinit does not carry over any
+// check that LinearAlgebra::distributed::Vector::reinit does not carry over any
 // state that can lead to invalid memory access. In this test, the MPI
 // communicator is deleted.
 
 
 #include "../tests.h"
 #include <deal.II/base/mpi.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/vector_memory.h>
 
 template <typename VectorType>
@@ -103,5 +103,5 @@ int main (int argc, char **argv)
 
   initlog();
 
-  do_test<parallel::distributed::Vector<double> >();
+  do_test<LinearAlgebra::distributed::Vector<double> >();
 }
index a6733055bcdc31fd7dce25992e5e56b8a90b035a..731fc34db68d35d957fee69060d2801d15dca174 100644 (file)
@@ -116,8 +116,8 @@ void test ()
     mf_data.reinit (dof, constraints, quad, data);
   }
 
-  MatrixFreeTest<dim,fe_degree,number,parallel::distributed::Vector<number> > mf (mf_data);
-  parallel::distributed::Vector<number> in, out, ref;
+  MatrixFreeTest<dim,fe_degree,number,LinearAlgebra::distributed::Vector<number> > mf (mf_data);
+  LinearAlgebra::distributed::Vector<number> in, out, ref;
   mf_data.initialize_dof_vector (in);
   out.reinit (in);
   ref.reinit (in);
index 70770c24532be72e279231d6f52b913c91c244e8..e1bae7227fd6491c7f851172f882d0b32a4595e0 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/function.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria_boundary_lib.h>
@@ -109,8 +109,8 @@ void test ()
     mf_data.reinit (dof, constraints, quad, data);
   }
 
-  MatrixFreeTest<dim,fe_degree,number,parallel::distributed::Vector<number> > mf (mf_data);
-  parallel::distributed::Vector<number> in, out, ref;
+  MatrixFreeTest<dim,fe_degree,number,LinearAlgebra::distributed::Vector<number> > mf (mf_data);
+  LinearAlgebra::distributed::Vector<number> in, out, ref;
   mf_data.initialize_dof_vector (in);
   out.reinit (in);
   ref.reinit (in);
@@ -152,7 +152,7 @@ void test ()
 
       data.tasks_block_size = 3;
       mf_data.reinit (dof, constraints, quad, data);
-      MatrixFreeTest<dim, fe_degree, number,parallel::distributed::Vector<number> > mf (mf_data);
+      MatrixFreeTest<dim, fe_degree, number,LinearAlgebra::distributed::Vector<number> > mf (mf_data);
       deallog << "Norm of difference:";
 
       // run 10 times to make a possible error more
index 4bda2828adc1e45e8d4f3af73a2a6520ad84ea10..5e4cf2ad3a684c904f96528c49470202ef503b3f 100644 (file)
@@ -26,7 +26,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/function.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria_boundary_lib.h>
@@ -45,8 +45,8 @@
 template <int dim, int fe_degree, typename Number>
 void
 helmholtz_operator (const MatrixFree<dim,Number>  &data,
-                    std::vector<parallel::distributed::Vector<Number> > &dst,
-                    const std::vector<parallel::distributed::Vector<Number> > &src,
+                    std::vector<LinearAlgebra::distributed::Vector<Number> > &dst,
+                    const std::vector<LinearAlgebra::distributed::Vector<Number> > &src,
                     const std::pair<unsigned int,unsigned int>  &cell_range)
 {
   FEEvaluation<dim,fe_degree,fe_degree+1,2,Number> fe_eval (data);
@@ -82,14 +82,14 @@ public:
     data (data_in)
   {};
 
-  void vmult (std::vector<parallel::distributed::Vector<Number> >       &dst,
-              const std::vector<parallel::distributed::Vector<Number> > &src) const
+  void vmult (std::vector<LinearAlgebra::distributed::Vector<Number> >       &dst,
+              const std::vector<LinearAlgebra::distributed::Vector<Number> > &src) const
   {
     for (unsigned int i=0; i<dst.size(); ++i)
       dst[i] = 0;
     const std_cxx11::function<void(const MatrixFree<dim,Number> &,
-                                   std::vector<parallel::distributed::Vector<Number> > &,
-                                   const std::vector<parallel::distributed::Vector<Number> > &,
+                                   std::vector<LinearAlgebra::distributed::Vector<Number> > &,
+                                   const std::vector<LinearAlgebra::distributed::Vector<Number> > &,
                                    const std::pair<unsigned int,unsigned int> &)>
     wrap = helmholtz_operator<dim,fe_degree,Number>;
     data.cell_loop (wrap, dst, src);
@@ -172,8 +172,8 @@ void test ()
   }
 
   MatrixFreeTest<dim,fe_degree,number> mf (mf_data);
-  parallel::distributed::Vector<number> ref;
-  std::vector<parallel::distributed::Vector<number> > in(2), out(2);
+  LinearAlgebra::distributed::Vector<number> ref;
+  std::vector<LinearAlgebra::distributed::Vector<number> > in(2), out(2);
   for (unsigned int i=0; i<2; ++i)
     {
       mf_data.initialize_dof_vector (in[i]);
index e7a0917c6d5a7fa09f26d94905f35ca4be31bf8e..f8d863cc3217c00a572a0e037ac3aa2592846814 100644 (file)
@@ -27,7 +27,7 @@
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/function.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria_boundary_lib.h>
@@ -46,8 +46,8 @@
 template <int dim, int fe_degree, typename Number>
 void
 helmholtz_operator (const MatrixFree<dim,Number>  &data,
-                    parallel::distributed::BlockVector<Number> &dst,
-                    const parallel::distributed::BlockVector<Number> &src,
+                    LinearAlgebra::distributed::BlockVector<Number> &dst,
+                    const LinearAlgebra::distributed::BlockVector<Number> &src,
                     const std::pair<unsigned int,unsigned int>  &cell_range)
 {
   FEEvaluation<dim,fe_degree,fe_degree+1,2,Number> fe_eval (data);
@@ -83,13 +83,13 @@ public:
     data (data_in)
   {};
 
-  void vmult (parallel::distributed::BlockVector<Number>       &dst,
-              const parallel::distributed::BlockVector<Number> &src) const
+  void vmult (LinearAlgebra::distributed::BlockVector<Number>       &dst,
+              const LinearAlgebra::distributed::BlockVector<Number> &src) const
   {
     dst = 0;
     const std_cxx11::function<void(const MatrixFree<dim,Number> &,
-                                   parallel::distributed::BlockVector<Number> &,
-                                   const parallel::distributed::BlockVector<Number> &,
+                                   LinearAlgebra::distributed::BlockVector<Number> &,
+                                   const LinearAlgebra::distributed::BlockVector<Number> &,
                                    const std::pair<unsigned int,unsigned int> &)>
     wrap = helmholtz_operator<dim,fe_degree,Number>;
     data.cell_loop (wrap, dst, src);
@@ -172,8 +172,8 @@ void test ()
   }
 
   MatrixFreeTest<dim,fe_degree,number> mf (mf_data);
-  parallel::distributed::Vector<number> ref;
-  parallel::distributed::BlockVector<number> in(2), out(2);
+  LinearAlgebra::distributed::Vector<number> ref;
+  LinearAlgebra::distributed::BlockVector<number> in(2), out(2);
   for (unsigned int i=0; i<2; ++i)
     {
       mf_data.initialize_dof_vector (in.block(i));
index e3efc81c0d48cda64afd6d28e2ed982ddea20bda..3b713a16e6d51768658b0c002f178ecb281274bb 100644 (file)
@@ -15,7 +15,7 @@
 #include <deal.II/matrix_free/fe_evaluation.h>
 
 #include <deal.II/lac/vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 
 
 template <int dim, int fe_degree, typename VectorType>
index 8b70abe32b4107c4cb344efa495a87c005437b61..56a50999345171a73d7234a80a773aa76775c0ba 100644 (file)
@@ -22,7 +22,7 @@
 
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/grid/tria.h>
@@ -110,28 +110,28 @@ public:
     compute_inverse_diagonal();
   }
 
-  void vmult(parallel::distributed::Vector<number> &dst,
-             const parallel::distributed::Vector<number> &src) const
+  void vmult(LinearAlgebra::distributed::Vector<number> &dst,
+             const LinearAlgebra::distributed::Vector<number> &src) const
   {
     dst = 0;
     vmult_add(dst, src);
   }
 
-  void Tvmult(parallel::distributed::Vector<number> &dst,
-              const parallel::distributed::Vector<number> &src) const
+  void Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
+              const LinearAlgebra::distributed::Vector<number> &src) const
   {
     dst = 0;
     vmult_add(dst, src);
   }
 
-  void Tvmult_add(parallel::distributed::Vector<number> &dst,
-                  const parallel::distributed::Vector<number> &src) const
+  void Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
+                  const LinearAlgebra::distributed::Vector<number> &src) const
   {
     vmult_add(dst, src);
   }
 
-  void vmult_add(parallel::distributed::Vector<number> &dst,
-                 const parallel::distributed::Vector<number> &src) const
+  void vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
+                 const LinearAlgebra::distributed::Vector<number> &src) const
   {
     data.cell_loop (&LaplaceOperator::local_apply,
                     this, dst, src);
@@ -159,7 +159,7 @@ public:
   }
 
   void
-  initialize_dof_vector(parallel::distributed::Vector<number> &vector) const
+  initialize_dof_vector(LinearAlgebra::distributed::Vector<number> &vector) const
   {
     if (!vector.partitioners_are_compatible(*data.get_dof_info(0).vector_partitioner))
       data.initialize_dof_vector(vector);
@@ -167,7 +167,7 @@ public:
            ExcInternalError());
   }
 
-  const parallel::distributed::Vector<number> &
+  const LinearAlgebra::distributed::Vector<number> &
   get_matrix_diagonal_inverse() const
   {
     Assert(inverse_diagonal_entries.size() > 0, ExcNotInitialized());
@@ -178,8 +178,8 @@ public:
 private:
   void
   local_apply (const MatrixFree<dim,number>                &data,
-               parallel::distributed::Vector<number>       &dst,
-               const parallel::distributed::Vector<number> &src,
+               LinearAlgebra::distributed::Vector<number>       &dst,
+               const LinearAlgebra::distributed::Vector<number> &src,
                const std::pair<unsigned int,unsigned int>  &cell_range) const
   {
     FEEvaluation<dim,fe_degree,n_q_points_1d,1,number> phi (data);
@@ -213,7 +213,7 @@ private:
 
   void
   local_diagonal_cell (const MatrixFree<dim,number>                &data,
-                       parallel::distributed::Vector<number>       &dst,
+                       LinearAlgebra::distributed::Vector<number>       &dst,
                        const unsigned int &,
                        const std::pair<unsigned int,unsigned int>  &cell_range) const
   {
@@ -242,13 +242,13 @@ private:
   }
 
   MatrixFree<dim,number> data;
-  parallel::distributed::Vector<number> inverse_diagonal_entries;
+  LinearAlgebra::distributed::Vector<number> inverse_diagonal_entries;
 };
 
 
 
 template <typename MatrixType>
-class MGTransferPrebuiltMF : public MGTransferPrebuilt<parallel::distributed::Vector<double> >
+class MGTransferPrebuiltMF : public MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >
 {
 public:
   MGTransferPrebuiltMF(const MGLevelObject<MatrixType> &laplace)
@@ -263,13 +263,13 @@ public:
   template <int dim, class InVector, int spacedim>
   void
   copy_to_mg (const DoFHandler<dim,spacedim> &mg_dof,
-              MGLevelObject<parallel::distributed::Vector<double> > &dst,
+              MGLevelObject<LinearAlgebra::distributed::Vector<double> > &dst,
               const InVector &src) const
   {
     for (unsigned int level=dst.min_level();
          level<=dst.max_level(); ++level)
       laplace_operator[level].initialize_dof_vector(dst[level]);
-    MGTransferPrebuilt<parallel::distributed::Vector<double> >::copy_to_mg(mg_dof, dst, src);
+    MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >::copy_to_mg(mg_dof, dst, src);
   }
 
 private:
@@ -279,7 +279,7 @@ private:
 
 
 template<typename MatrixType, typename Number>
-class MGCoarseIterative : public MGCoarseGridBase<parallel::distributed::Vector<Number> >
+class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
 {
 public:
   MGCoarseIterative() {}
@@ -290,11 +290,11 @@ public:
   }
 
   virtual void operator() (const unsigned int   level,
-                           parallel::distributed::Vector<double> &dst,
-                           const parallel::distributed::Vector<double> &src) const
+                           LinearAlgebra::distributed::Vector<double> &dst,
+                           const LinearAlgebra::distributed::Vector<double> &src) const
   {
     ReductionControl solver_control (1e4, 1e-50, 1e-10);
-    SolverCG<parallel::distributed::Vector<double> > solver_coarse (solver_control);
+    SolverCG<LinearAlgebra::distributed::Vector<double> > solver_coarse (solver_control);
     solver_coarse.solve (*coarse_matrix, dst, src, PreconditionIdentity());
   }
 
@@ -327,7 +327,7 @@ void do_test (const DoFHandler<dim>  &dof)
   dirichlet_boundaries.insert(0);
   fine_matrix.initialize(mapping, dof, dirichlet_boundaries);
 
-  parallel::distributed::Vector<number> in, sol;
+  LinearAlgebra::distributed::Vector<number> in, sol;
   fine_matrix.initialize_dof_vector(in);
   fine_matrix.initialize_dof_vector(sol);
 
@@ -350,8 +350,8 @@ void do_test (const DoFHandler<dim>  &dof)
   MGCoarseIterative<LevelMatrixType,number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,parallel::distributed::Vector<number> > SMOOTHER;
-  MGSmootherPrecondition<LevelMatrixType, SMOOTHER, parallel::distributed::Vector<number> >
+  typedef PreconditionChebyshev<LevelMatrixType,LinearAlgebra::distributed::Vector<number> > SMOOTHER;
+  MGSmootherPrecondition<LevelMatrixType, SMOOTHER, LinearAlgebra::distributed::Vector<number> >
   mg_smoother;
 
   MGLevelObject<typename SMOOTHER::AdditionalData> smoother_data;
@@ -366,22 +366,22 @@ void do_test (const DoFHandler<dim>  &dof)
     }
   mg_smoother.initialize(mg_matrices, smoother_data);
 
-  mg::Matrix<parallel::distributed::Vector<double> >
+  mg::Matrix<LinearAlgebra::distributed::Vector<double> >
   mg_matrix(mg_matrices);
 
-  Multigrid<parallel::distributed::Vector<double> > mg(dof,
-                                                       mg_matrix,
-                                                       mg_coarse,
-                                                       mg_transfer,
-                                                       mg_smoother,
-                                                       mg_smoother);
-  PreconditionMG<dim, parallel::distributed::Vector<double>,
+  Multigrid<LinearAlgebra::distributed::Vector<double> > mg(dof,
+                                                            mg_matrix,
+                                                            mg_coarse,
+                                                            mg_transfer,
+                                                            mg_smoother,
+                                                            mg_smoother);
+  PreconditionMG<dim, LinearAlgebra::distributed::Vector<double>,
                  MGTransferPrebuiltMF<LevelMatrixType> >
                  preconditioner(dof, mg, mg_transfer);
 
   {
     ReductionControl control(30, 1e-20, 1e-7);
-    SolverCG<parallel::distributed::Vector<double> > solver(control);
+    SolverCG<LinearAlgebra::distributed::Vector<double> > solver(control);
     solver.solve(fine_matrix, sol, in, preconditioner);
   }
 
index c71f490db8b168c1761487c71044a9fed381560f..b134b460b5fcf386d7995820d2153566dc404990 100644 (file)
@@ -22,7 +22,7 @@
 
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/grid/tria.h>
@@ -103,28 +103,28 @@ public:
       compute_inverse_diagonal();
   }
 
-  void vmult(parallel::distributed::Vector<number> &dst,
-             const parallel::distributed::Vector<number> &src) const
+  void vmult(LinearAlgebra::distributed::Vector<number> &dst,
+             const LinearAlgebra::distributed::Vector<number> &src) const
   {
     dst = 0;
     vmult_add(dst, src);
   }
 
-  void Tvmult(parallel::distributed::Vector<number> &dst,
-              const parallel::distributed::Vector<number> &src) const
+  void Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
+              const LinearAlgebra::distributed::Vector<number> &src) const
   {
     dst = 0;
     vmult_add(dst, src);
   }
 
-  void Tvmult_add(parallel::distributed::Vector<number> &dst,
-                  const parallel::distributed::Vector<number> &src) const
+  void Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
+                  const LinearAlgebra::distributed::Vector<number> &src) const
   {
     vmult_add(dst, src);
   }
 
-  void vmult_add(parallel::distributed::Vector<number> &dst,
-                 const parallel::distributed::Vector<number> &src) const
+  void vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
+                 const LinearAlgebra::distributed::Vector<number> &src) const
   {
     Assert(src.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
     Assert(dst.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
@@ -136,7 +136,7 @@ public:
         edge_constrained_values[i] =
           std::pair<number,number>(src.local_element(edge_constrained_indices[i]),
                                    dst.local_element(edge_constrained_indices[i]));
-        const_cast<parallel::distributed::Vector<double>&>(src).local_element(edge_constrained_indices[i]) = 0.;
+        const_cast<LinearAlgebra::distributed::Vector<double>&>(src).local_element(edge_constrained_indices[i]) = 0.;
       }
 
     data.cell_loop (&LaplaceOperator::local_apply,
@@ -151,13 +151,13 @@ public:
     // destination
     for (unsigned int i=0; i<edge_constrained_indices.size(); ++i)
       {
-        const_cast<parallel::distributed::Vector<double>&>(src).local_element(edge_constrained_indices[i]) = edge_constrained_values[i].first;
+        const_cast<LinearAlgebra::distributed::Vector<double>&>(src).local_element(edge_constrained_indices[i]) = edge_constrained_values[i].first;
         dst.local_element(edge_constrained_indices[i]) = edge_constrained_values[i].second + edge_constrained_values[i].first;
       }
   }
 
-  void vmult_interface_down(parallel::distributed::Vector<double> &dst,
-                            const parallel::distributed::Vector<double> &src) const
+  void vmult_interface_down(LinearAlgebra::distributed::Vector<double> &dst,
+                            const LinearAlgebra::distributed::Vector<double> &src) const
   {
     Assert(src.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
     Assert(dst.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
@@ -172,7 +172,7 @@ public:
     for (unsigned int i=0; i<edge_constrained_indices.size(); ++i)
       {
         const double src_val = src.local_element(edge_constrained_indices[i]);
-        const_cast<parallel::distributed::Vector<double>&>(src).local_element(edge_constrained_indices[i]) = 0.;
+        const_cast<LinearAlgebra::distributed::Vector<double>&>(src).local_element(edge_constrained_indices[i]) = 0.;
         edge_constrained_values[i] = std::pair<number,number>(src_val,
                                                               dst.local_element(edge_constrained_indices[i]));
       }
@@ -188,14 +188,14 @@ public:
         ++c;
 
         // reset the src values
-        const_cast<parallel::distributed::Vector<double>&>(src).local_element(edge_constrained_indices[i]) = edge_constrained_values[i].first;
+        const_cast<LinearAlgebra::distributed::Vector<double>&>(src).local_element(edge_constrained_indices[i]) = edge_constrained_values[i].first;
       }
     for ( ; c<dst.local_size(); ++c)
       dst.local_element(c) = 0.;
   }
 
-  void vmult_interface_up(parallel::distributed::Vector<double> &dst,
-                          const parallel::distributed::Vector<double> &src) const
+  void vmult_interface_up(LinearAlgebra::distributed::Vector<double> &dst,
+                          const LinearAlgebra::distributed::Vector<double> &src) const
   {
     Assert(src.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
     Assert(dst.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
@@ -205,7 +205,7 @@ public:
     if (!have_interface_matrices)
       return;
 
-    parallel::distributed::Vector<double> src_cpy (src);
+    LinearAlgebra::distributed::Vector<double> src_cpy (src);
     unsigned int c=0;
     for (unsigned int i=0; i<edge_constrained_indices.size(); ++i)
       {
@@ -241,7 +241,7 @@ public:
   }
 
   void
-  initialize_dof_vector(parallel::distributed::Vector<number> &vector) const
+  initialize_dof_vector(LinearAlgebra::distributed::Vector<number> &vector) const
   {
     if (!vector.partitioners_are_compatible(*data.get_dof_info(0).vector_partitioner))
       data.initialize_dof_vector(vector);
@@ -249,7 +249,7 @@ public:
            ExcInternalError());
   }
 
-  const parallel::distributed::Vector<number> &
+  const LinearAlgebra::distributed::Vector<number> &
   get_matrix_diagonal_inverse() const
   {
     Assert(inverse_diagonal_entries.size() > 0, ExcNotInitialized());
@@ -260,8 +260,8 @@ public:
 private:
   void
   local_apply (const MatrixFree<dim,number>                &data,
-               parallel::distributed::Vector<number>       &dst,
-               const parallel::distributed::Vector<number> &src,
+               LinearAlgebra::distributed::Vector<number>       &dst,
+               const LinearAlgebra::distributed::Vector<number> &src,
                const std::pair<unsigned int,unsigned int>  &cell_range) const
   {
     FEEvaluation<dim,fe_degree,n_q_points_1d,1,number> phi (data);
@@ -305,7 +305,7 @@ private:
 
   void
   local_diagonal_cell (const MatrixFree<dim,number>                &data,
-                       parallel::distributed::Vector<number>       &dst,
+                       LinearAlgebra::distributed::Vector<number>       &dst,
                        const unsigned int &,
                        const std::pair<unsigned int,unsigned int>  &cell_range) const
   {
@@ -334,7 +334,7 @@ private:
   }
 
   MatrixFree<dim,number> data;
-  parallel::distributed::Vector<number> inverse_diagonal_entries;
+  LinearAlgebra::distributed::Vector<number> inverse_diagonal_entries;
   std::vector<unsigned int> edge_constrained_indices;
   mutable std::vector<std::pair<number,number> > edge_constrained_values;
   bool have_interface_matrices;
@@ -351,14 +351,14 @@ public:
     this->laplace = &laplace;
   }
 
-  void vmult (parallel::distributed::Vector<double> &dst,
-              const parallel::distributed::Vector<double> &src) const
+  void vmult (LinearAlgebra::distributed::Vector<double> &dst,
+              const LinearAlgebra::distributed::Vector<double> &src) const
   {
     laplace->vmult_interface_down(dst, src);
   }
 
-  void Tvmult (parallel::distributed::Vector<double> &dst,
-               const parallel::distributed::Vector<double> &src) const
+  void Tvmult (LinearAlgebra::distributed::Vector<double> &dst,
+               const LinearAlgebra::distributed::Vector<double> &src) const
   {
     laplace->vmult_interface_up(dst, src);
   }
@@ -370,15 +370,15 @@ private:
 
 
 template <typename LAPLACEOPERATOR>
-class MGTransferMF : public MGTransferPrebuilt<parallel::distributed::Vector<double> >
+class MGTransferMF : public MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >
 {
 public:
   MGTransferMF(const MGLevelObject<LAPLACEOPERATOR> &laplace,
                const ConstraintMatrix &hanging_node_constraints,
                const MGConstrainedDoFs &mg_constrained_dofs)
     :
-    MGTransferPrebuilt<parallel::distributed::Vector<double> >(hanging_node_constraints,
-                                                               mg_constrained_dofs),
+    MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >(hanging_node_constraints,
+        mg_constrained_dofs),
     laplace_operator (laplace)
   {
   }
@@ -391,13 +391,13 @@ public:
   template <int dim, class InVector, int spacedim>
   void
   copy_to_mg (const DoFHandler<dim,spacedim> &mg_dof_handler,
-              MGLevelObject<parallel::distributed::Vector<double> > &dst,
+              MGLevelObject<LinearAlgebra::distributed::Vector<double> > &dst,
               const InVector &src) const
   {
     for (unsigned int level=dst.min_level();
          level<=dst.max_level(); ++level)
       laplace_operator[level].initialize_dof_vector(dst[level]);
-    MGTransferPrebuilt<parallel::distributed::Vector<double> >::
+    MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >::
     copy_to_mg(mg_dof_handler, dst, src);
   }
 
@@ -408,7 +408,7 @@ private:
 
 
 template<typename MatrixType, typename Number>
-class MGCoarseIterative : public MGCoarseGridBase<parallel::distributed::Vector<Number> >
+class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
 {
 public:
   MGCoarseIterative() {}
@@ -419,11 +419,11 @@ public:
   }
 
   virtual void operator() (const unsigned int   level,
-                           parallel::distributed::Vector<double> &dst,
-                           const parallel::distributed::Vector<double> &src) const
+                           LinearAlgebra::distributed::Vector<double> &dst,
+                           const LinearAlgebra::distributed::Vector<double> &src) const
   {
     ReductionControl solver_control (1e4, 1e-50, 1e-10);
-    SolverCG<parallel::distributed::Vector<double> > solver_coarse (solver_control);
+    SolverCG<LinearAlgebra::distributed::Vector<double> > solver_coarse (solver_control);
     solver_coarse.solve (*coarse_matrix, dst, src, PreconditionIdentity());
   }
 
@@ -468,7 +468,7 @@ void do_test (const DoFHandler<dim>  &dof)
   fine_matrix.initialize(mapping, dof, mg_constrained_dofs, dirichlet_boundary,
                          numbers::invalid_unsigned_int);
 
-  parallel::distributed::Vector<number> in, sol;
+  LinearAlgebra::distributed::Vector<number> in, sol;
   fine_matrix.initialize_dof_vector(in);
   fine_matrix.initialize_dof_vector(sol);
 
@@ -500,8 +500,8 @@ void do_test (const DoFHandler<dim>  &dof)
   MGCoarseIterative<LevelMatrixType,number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,parallel::distributed::Vector<number> > SMOOTHER;
-  MGSmootherPrecondition<LevelMatrixType, SMOOTHER, parallel::distributed::Vector<number> >
+  typedef PreconditionChebyshev<LevelMatrixType,LinearAlgebra::distributed::Vector<number> > SMOOTHER;
+  MGSmootherPrecondition<LevelMatrixType, SMOOTHER, LinearAlgebra::distributed::Vector<number> >
   mg_smoother;
 
   MGLevelObject<typename SMOOTHER::AdditionalData> smoother_data;
@@ -516,25 +516,25 @@ void do_test (const DoFHandler<dim>  &dof)
     }
   mg_smoother.initialize(mg_matrices, smoother_data);
 
-  mg::Matrix<parallel::distributed::Vector<double> >
+  mg::Matrix<LinearAlgebra::distributed::Vector<double> >
   mg_matrix(mg_matrices);
-  mg::Matrix<parallel::distributed::Vector<double> >
+  mg::Matrix<LinearAlgebra::distributed::Vector<double> >
   mg_interface(mg_interface_matrices);
 
-  Multigrid<parallel::distributed::Vector<double> > mg(dof,
-                                                       mg_matrix,
-                                                       mg_coarse,
-                                                       mg_transfer,
-                                                       mg_smoother,
-                                                       mg_smoother);
+  Multigrid<LinearAlgebra::distributed::Vector<double> > mg(dof,
+                                                            mg_matrix,
+                                                            mg_coarse,
+                                                            mg_transfer,
+                                                            mg_smoother,
+                                                            mg_smoother);
   mg.set_edge_matrices(mg_interface, mg_interface);
-  PreconditionMG<dim, parallel::distributed::Vector<double>,
+  PreconditionMG<dim, LinearAlgebra::distributed::Vector<double>,
                  MGTransferMF<LevelMatrixType> >
                  preconditioner(dof, mg, mg_transfer);
 
   {
     ReductionControl control(30, 1e-20, 1e-7);
-    SolverCG<parallel::distributed::Vector<double> > solver(control);
+    SolverCG<LinearAlgebra::distributed::Vector<double> > solver(control);
     solver.solve(fine_matrix, sol, in, preconditioner);
   }
 
index 10e5099e66ec15f1ebfe4bbaf004e3e59dd38c44..bcd35df53dd61582e825a12e303b21395c1bb083 100644 (file)
@@ -21,7 +21,7 @@
 
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/grid/tria.h>
@@ -102,28 +102,28 @@ public:
       compute_inverse_diagonal();
   }
 
-  void vmult(parallel::distributed::Vector<number> &dst,
-             const parallel::distributed::Vector<number> &src) const
+  void vmult(LinearAlgebra::distributed::Vector<number> &dst,
+             const LinearAlgebra::distributed::Vector<number> &src) const
   {
     dst = 0;
     vmult_add(dst, src);
   }
 
-  void Tvmult(parallel::distributed::Vector<number> &dst,
-              const parallel::distributed::Vector<number> &src) const
+  void Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
+              const LinearAlgebra::distributed::Vector<number> &src) const
   {
     dst = 0;
     vmult_add(dst, src);
   }
 
-  void Tvmult_add(parallel::distributed::Vector<number> &dst,
-                  const parallel::distributed::Vector<number> &src) const
+  void Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
+                  const LinearAlgebra::distributed::Vector<number> &src) const
   {
     vmult_add(dst, src);
   }
 
-  void vmult_add(parallel::distributed::Vector<number> &dst,
-                 const parallel::distributed::Vector<number> &src) const
+  void vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
+                 const LinearAlgebra::distributed::Vector<number> &src) const
   {
     Assert(src.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
     Assert(dst.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
@@ -135,7 +135,7 @@ public:
         edge_constrained_values[i] =
           std::pair<number,number>(src.local_element(edge_constrained_indices[i]),
                                    dst.local_element(edge_constrained_indices[i]));
-        const_cast<parallel::distributed::Vector<number>&>(src).local_element(edge_constrained_indices[i]) = 0.;
+        const_cast<LinearAlgebra::distributed::Vector<number>&>(src).local_element(edge_constrained_indices[i]) = 0.;
       }
 
     data.cell_loop (&LaplaceOperator::local_apply,
@@ -150,13 +150,13 @@ public:
     // destination
     for (unsigned int i=0; i<edge_constrained_indices.size(); ++i)
       {
-        const_cast<parallel::distributed::Vector<number>&>(src).local_element(edge_constrained_indices[i]) = edge_constrained_values[i].first;
+        const_cast<LinearAlgebra::distributed::Vector<number>&>(src).local_element(edge_constrained_indices[i]) = edge_constrained_values[i].first;
         dst.local_element(edge_constrained_indices[i]) = edge_constrained_values[i].second + edge_constrained_values[i].first;
       }
   }
 
-  void vmult_interface_down(parallel::distributed::Vector<number> &dst,
-                            const parallel::distributed::Vector<number> &src) const
+  void vmult_interface_down(LinearAlgebra::distributed::Vector<number> &dst,
+                            const LinearAlgebra::distributed::Vector<number> &src) const
   {
     Assert(src.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
     Assert(dst.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
@@ -171,7 +171,7 @@ public:
     for (unsigned int i=0; i<edge_constrained_indices.size(); ++i)
       {
         const double src_val = src.local_element(edge_constrained_indices[i]);
-        const_cast<parallel::distributed::Vector<number>&>(src).local_element(edge_constrained_indices[i]) = 0.;
+        const_cast<LinearAlgebra::distributed::Vector<number>&>(src).local_element(edge_constrained_indices[i]) = 0.;
         edge_constrained_values[i] = std::pair<number,number>(src_val,
                                                               dst.local_element(edge_constrained_indices[i]));
       }
@@ -187,14 +187,14 @@ public:
         ++c;
 
         // reset the src values
-        const_cast<parallel::distributed::Vector<number>&>(src).local_element(edge_constrained_indices[i]) = edge_constrained_values[i].first;
+        const_cast<LinearAlgebra::distributed::Vector<number>&>(src).local_element(edge_constrained_indices[i]) = edge_constrained_values[i].first;
       }
     for ( ; c<dst.local_size(); ++c)
       dst.local_element(c) = 0.;
   }
 
-  void vmult_interface_up(parallel::distributed::Vector<number> &dst,
-                          const parallel::distributed::Vector<number> &src) const
+  void vmult_interface_up(LinearAlgebra::distributed::Vector<number> &dst,
+                          const LinearAlgebra::distributed::Vector<number> &src) const
   {
     Assert(src.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
     Assert(dst.partitioners_are_globally_compatible(*data.get_dof_info(0).vector_partitioner), ExcInternalError());
@@ -204,7 +204,7 @@ public:
     if (!have_interface_matrices)
       return;
 
-    parallel::distributed::Vector<number> src_cpy (src);
+    LinearAlgebra::distributed::Vector<number> src_cpy (src);
     unsigned int c=0;
     for (unsigned int i=0; i<edge_constrained_indices.size(); ++i)
       {
@@ -240,7 +240,7 @@ public:
   }
 
   void
-  initialize_dof_vector(parallel::distributed::Vector<number> &vector) const
+  initialize_dof_vector(LinearAlgebra::distributed::Vector<number> &vector) const
   {
     if (!vector.partitioners_are_compatible(*data.get_dof_info(0).vector_partitioner))
       data.initialize_dof_vector(vector);
@@ -248,7 +248,7 @@ public:
            ExcInternalError());
   }
 
-  const parallel::distributed::Vector<number> &
+  const LinearAlgebra::distributed::Vector<number> &
   get_matrix_diagonal_inverse() const
   {
     Assert(inverse_diagonal_entries.size() > 0, ExcNotInitialized());
@@ -259,8 +259,8 @@ public:
 private:
   void
   local_apply (const MatrixFree<dim,number>                &data,
-               parallel::distributed::Vector<number>       &dst,
-               const parallel::distributed::Vector<number> &src,
+               LinearAlgebra::distributed::Vector<number>       &dst,
+               const LinearAlgebra::distributed::Vector<number> &src,
                const std::pair<unsigned int,unsigned int>  &cell_range) const
   {
     FEEvaluation<dim,fe_degree,n_q_points_1d,1,number> phi (data);
@@ -304,7 +304,7 @@ private:
 
   void
   local_diagonal_cell (const MatrixFree<dim,number>                &data,
-                       parallel::distributed::Vector<number>       &dst,
+                       LinearAlgebra::distributed::Vector<number>       &dst,
                        const unsigned int &,
                        const std::pair<unsigned int,unsigned int>  &cell_range) const
   {
@@ -333,7 +333,7 @@ private:
   }
 
   MatrixFree<dim,number> data;
-  parallel::distributed::Vector<number> inverse_diagonal_entries;
+  LinearAlgebra::distributed::Vector<number> inverse_diagonal_entries;
   std::vector<unsigned int> edge_constrained_indices;
   mutable std::vector<std::pair<number,number> > edge_constrained_values;
   bool have_interface_matrices;
@@ -350,14 +350,14 @@ public:
     this->laplace = &laplace;
   }
 
-  void vmult (parallel::distributed::Vector<typename LAPLACEOPERATOR::value_type> &dst,
-              const parallel::distributed::Vector<typename LAPLACEOPERATOR::value_type> &src) const
+  void vmult (LinearAlgebra::distributed::Vector<typename LAPLACEOPERATOR::value_type> &dst,
+              const LinearAlgebra::distributed::Vector<typename LAPLACEOPERATOR::value_type> &src) const
   {
     laplace->vmult_interface_down(dst, src);
   }
 
-  void Tvmult (parallel::distributed::Vector<typename LAPLACEOPERATOR::value_type> &dst,
-               const parallel::distributed::Vector<typename LAPLACEOPERATOR::value_type> &src) const
+  void Tvmult (LinearAlgebra::distributed::Vector<typename LAPLACEOPERATOR::value_type> &dst,
+               const LinearAlgebra::distributed::Vector<typename LAPLACEOPERATOR::value_type> &src) const
   {
     laplace->vmult_interface_up(dst, src);
   }
@@ -388,13 +388,13 @@ public:
   template <class InVector, int spacedim>
   void
   copy_to_mg (const DoFHandler<dim,spacedim> &mg_dof_handler,
-              MGLevelObject<parallel::distributed::Vector<typename LAPLACEOPERATOR::value_type> > &dst,
+              MGLevelObject<LinearAlgebra::distributed::Vector<typename LAPLACEOPERATOR::value_type> > &dst,
               const InVector &src) const
   {
     for (unsigned int level=dst.min_level();
          level<=dst.max_level(); ++level)
       laplace_operator[level].initialize_dof_vector(dst[level]);
-    MGLevelGlobalTransfer<parallel::distributed::Vector<typename LAPLACEOPERATOR::value_type> >::
+    MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<typename LAPLACEOPERATOR::value_type> >::
     copy_to_mg(mg_dof_handler, dst, src);
   }
 
@@ -405,7 +405,7 @@ private:
 
 
 template<typename MatrixType, typename Number>
-class MGCoarseIterative : public MGCoarseGridBase<parallel::distributed::Vector<Number> >
+class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
 {
 public:
   MGCoarseIterative() {}
@@ -416,11 +416,11 @@ public:
   }
 
   virtual void operator() (const unsigned int   level,
-                           parallel::distributed::Vector<Number> &dst,
-                           const parallel::distributed::Vector<Number> &src) const
+                           LinearAlgebra::distributed::Vector<Number> &dst,
+                           const LinearAlgebra::distributed::Vector<Number> &src) const
   {
     ReductionControl solver_control (1e4, 1e-50, 1e-10);
-    SolverCG<parallel::distributed::Vector<Number> > solver_coarse (solver_control);
+    SolverCG<LinearAlgebra::distributed::Vector<Number> > solver_coarse (solver_control);
     solver_coarse.solve (*coarse_matrix, dst, src, PreconditionIdentity());
   }
 
@@ -455,7 +455,7 @@ void do_test (const DoFHandler<dim>  &dof)
   fine_matrix.initialize(mapping, dof, mg_constrained_dofs, dirichlet_boundary,
                          numbers::invalid_unsigned_int);
 
-  parallel::distributed::Vector<double> in, sol;
+  LinearAlgebra::distributed::Vector<double> in, sol;
   fine_matrix.initialize_dof_vector(in);
   fine_matrix.initialize_dof_vector(sol);
 
@@ -486,8 +486,8 @@ void do_test (const DoFHandler<dim>  &dof)
   MGCoarseIterative<LevelMatrixType,number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,parallel::distributed::Vector<number> > SMOOTHER;
-  MGSmootherPrecondition<LevelMatrixType, SMOOTHER, parallel::distributed::Vector<number> >
+  typedef PreconditionChebyshev<LevelMatrixType,LinearAlgebra::distributed::Vector<number> > SMOOTHER;
+  MGSmootherPrecondition<LevelMatrixType, SMOOTHER, LinearAlgebra::distributed::Vector<number> >
   mg_smoother;
 
   MGLevelObject<typename SMOOTHER::AdditionalData> smoother_data;
@@ -506,19 +506,19 @@ void do_test (const DoFHandler<dim>  &dof)
   deallog.depth_file(0);
   mg_smoother.initialize(mg_matrices, smoother_data);
 
-  mg::Matrix<parallel::distributed::Vector<number> >
+  mg::Matrix<LinearAlgebra::distributed::Vector<number> >
   mg_matrix(mg_matrices);
-  mg::Matrix<parallel::distributed::Vector<number> >
+  mg::Matrix<LinearAlgebra::distributed::Vector<number> >
   mg_interface(mg_interface_matrices);
 
-  Multigrid<parallel::distributed::Vector<number> > mg(dof,
-                                                       mg_matrix,
-                                                       mg_coarse,
-                                                       mg_transfer,
-                                                       mg_smoother,
-                                                       mg_smoother);
+  Multigrid<LinearAlgebra::distributed::Vector<number> > mg(dof,
+                                                            mg_matrix,
+                                                            mg_coarse,
+                                                            mg_transfer,
+                                                            mg_smoother,
+                                                            mg_smoother);
   mg.set_edge_matrices(mg_interface, mg_interface);
-  PreconditionMG<dim, parallel::distributed::Vector<number>,
+  PreconditionMG<dim, LinearAlgebra::distributed::Vector<number>,
                  MGTransferMF<dim,LevelMatrixType> >
                  preconditioner(dof, mg, mg_transfer);
 
@@ -526,7 +526,7 @@ void do_test (const DoFHandler<dim>  &dof)
     // avoid output from inner (coarse-level) solver
     deallog.depth_file(2);
     ReductionControl control(30, 1e-20, 1e-7);
-    SolverCG<parallel::distributed::Vector<double> > solver(control);
+    SolverCG<LinearAlgebra::distributed::Vector<double> > solver(control);
     solver.solve(fine_matrix, sol, in, preconditioner);
   }
 }
index 1674f7c430ceaa0aaa72a86be5aaf6dfefdaa796..5ff611f1cf685000a89e174d9d46e2ed1371fea1 100644 (file)
@@ -21,7 +21,7 @@
 
 #include <deal.II/base/logstream.h>
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/solver_cg.h>
 #include <deal.II/lac/precondition.h>
 #include <deal.II/grid/tria.h>
@@ -109,28 +109,28 @@ public:
     compute_inverse_diagonal();
   }
 
-  void vmult(parallel::distributed::Vector<number> &dst,
-             const parallel::distributed::Vector<number> &src) const
+  void vmult(LinearAlgebra::distributed::Vector<number> &dst,
+             const LinearAlgebra::distributed::Vector<number> &src) const
   {
     dst = 0;
     vmult_add(dst, src);
   }
 
-  void Tvmult(parallel::distributed::Vector<number> &dst,
-              const parallel::distributed::Vector<number> &src) const
+  void Tvmult(LinearAlgebra::distributed::Vector<number> &dst,
+              const LinearAlgebra::distributed::Vector<number> &src) const
   {
     dst = 0;
     vmult_add(dst, src);
   }
 
-  void Tvmult_add(parallel::distributed::Vector<number> &dst,
-                  const parallel::distributed::Vector<number> &src) const
+  void Tvmult_add(LinearAlgebra::distributed::Vector<number> &dst,
+                  const LinearAlgebra::distributed::Vector<number> &src) const
   {
     vmult_add(dst, src);
   }
 
-  void vmult_add(parallel::distributed::Vector<number> &dst,
-                 const parallel::distributed::Vector<number> &src) const
+  void vmult_add(LinearAlgebra::distributed::Vector<number> &dst,
+                 const LinearAlgebra::distributed::Vector<number> &src) const
   {
     data.cell_loop (&LaplaceOperator::local_apply,
                     this, dst, src);
@@ -158,7 +158,7 @@ public:
   }
 
   void
-  initialize_dof_vector(parallel::distributed::Vector<number> &vector) const
+  initialize_dof_vector(LinearAlgebra::distributed::Vector<number> &vector) const
   {
     if (!vector.partitioners_are_compatible(*data.get_dof_info(0).vector_partitioner))
       data.initialize_dof_vector(vector);
@@ -166,7 +166,7 @@ public:
            ExcInternalError());
   }
 
-  const parallel::distributed::Vector<number> &
+  const LinearAlgebra::distributed::Vector<number> &
   get_matrix_diagonal_inverse() const
   {
     Assert(inverse_diagonal_entries.size() > 0, ExcNotInitialized());
@@ -177,8 +177,8 @@ public:
 private:
   void
   local_apply (const MatrixFree<dim,number>                &data,
-               parallel::distributed::Vector<number>       &dst,
-               const parallel::distributed::Vector<number> &src,
+               LinearAlgebra::distributed::Vector<number>       &dst,
+               const LinearAlgebra::distributed::Vector<number> &src,
                const std::pair<unsigned int,unsigned int>  &cell_range) const
   {
     FEEvaluation<dim,fe_degree,n_q_points_1d,1,number> phi (data);
@@ -212,7 +212,7 @@ private:
 
   void
   local_diagonal_cell (const MatrixFree<dim,number>                &data,
-                       parallel::distributed::Vector<number>       &dst,
+                       LinearAlgebra::distributed::Vector<number>       &dst,
                        const unsigned int &,
                        const std::pair<unsigned int,unsigned int>  &cell_range) const
   {
@@ -241,7 +241,7 @@ private:
   }
 
   MatrixFree<dim,number> data;
-  parallel::distributed::Vector<number> inverse_diagonal_entries;
+  LinearAlgebra::distributed::Vector<number> inverse_diagonal_entries;
 };
 
 
@@ -264,13 +264,13 @@ public:
   template <class InVector, int spacedim>
   void
   copy_to_mg (const DoFHandler<dim,spacedim> &mg_dof,
-              MGLevelObject<parallel::distributed::Vector<typename MatrixType::value_type> > &dst,
+              MGLevelObject<LinearAlgebra::distributed::Vector<typename MatrixType::value_type> > &dst,
               const InVector &src) const
   {
     for (unsigned int level=dst.min_level();
          level<=dst.max_level(); ++level)
       laplace_operator[level].initialize_dof_vector(dst[level]);
-    MGLevelGlobalTransfer<parallel::distributed::Vector<typename MatrixType::value_type> >::copy_to_mg(mg_dof, dst, src);
+    MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<typename MatrixType::value_type> >::copy_to_mg(mg_dof, dst, src);
   }
 
 private:
@@ -280,7 +280,7 @@ private:
 
 
 template<typename MatrixType, typename Number>
-class MGCoarseIterative : public MGCoarseGridBase<parallel::distributed::Vector<Number> >
+class MGCoarseIterative : public MGCoarseGridBase<LinearAlgebra::distributed::Vector<Number> >
 {
 public:
   MGCoarseIterative() {}
@@ -291,11 +291,11 @@ public:
   }
 
   virtual void operator() (const unsigned int   level,
-                           parallel::distributed::Vector<Number> &dst,
-                           const parallel::distributed::Vector<Number> &src) const
+                           LinearAlgebra::distributed::Vector<Number> &dst,
+                           const LinearAlgebra::distributed::Vector<Number> &src) const
   {
     ReductionControl solver_control (1e4, 1e-50, 1e-10);
-    SolverCG<parallel::distributed::Vector<Number> > solver_coarse (solver_control);
+    SolverCG<LinearAlgebra::distributed::Vector<Number> > solver_coarse (solver_control);
     solver_coarse.solve (*coarse_matrix, dst, src, PreconditionIdentity());
   }
 
@@ -318,7 +318,7 @@ void do_test (const DoFHandler<dim>  &dof)
   dirichlet_boundaries.insert(0);
   fine_matrix.initialize(mapping, dof, dirichlet_boundaries);
 
-  parallel::distributed::Vector<double> in, sol;
+  LinearAlgebra::distributed::Vector<double> in, sol;
   fine_matrix.initialize_dof_vector(in);
   fine_matrix.initialize_dof_vector(sol);
 
@@ -347,8 +347,8 @@ void do_test (const DoFHandler<dim>  &dof)
   MGCoarseIterative<LevelMatrixType,number> mg_coarse;
   mg_coarse.initialize(mg_matrices[0]);
 
-  typedef PreconditionChebyshev<LevelMatrixType,parallel::distributed::Vector<number> > SMOOTHER;
-  MGSmootherPrecondition<LevelMatrixType, SMOOTHER, parallel::distributed::Vector<number> >
+  typedef PreconditionChebyshev<LevelMatrixType,LinearAlgebra::distributed::Vector<number> > SMOOTHER;
+  MGSmootherPrecondition<LevelMatrixType, SMOOTHER, LinearAlgebra::distributed::Vector<number> >
   mg_smoother;
 
   MGLevelObject<typename SMOOTHER::AdditionalData> smoother_data;
@@ -367,16 +367,16 @@ void do_test (const DoFHandler<dim>  &dof)
   deallog.depth_file(0);
   mg_smoother.initialize(mg_matrices, smoother_data);
 
-  mg::Matrix<parallel::distributed::Vector<number> >
+  mg::Matrix<LinearAlgebra::distributed::Vector<number> >
   mg_matrix(mg_matrices);
 
-  Multigrid<parallel::distributed::Vector<number> > mg(dof,
-                                                       mg_matrix,
-                                                       mg_coarse,
-                                                       mg_transfer,
-                                                       mg_smoother,
-                                                       mg_smoother);
-  PreconditionMG<dim, parallel::distributed::Vector<number>,
+  Multigrid<LinearAlgebra::distributed::Vector<number> > mg(dof,
+                                                            mg_matrix,
+                                                            mg_coarse,
+                                                            mg_transfer,
+                                                            mg_smoother,
+                                                            mg_smoother);
+  PreconditionMG<dim, LinearAlgebra::distributed::Vector<number>,
                  MGTransferPrebuiltMF<dim,LevelMatrixType> >
                  preconditioner(dof, mg, mg_transfer);
 
@@ -384,7 +384,7 @@ void do_test (const DoFHandler<dim>  &dof)
     // avoid output from inner (coarse-level) solver
     deallog.depth_file(2);
     ReductionControl control(30, 1e-20, 1e-7);
-    SolverCG<parallel::distributed::Vector<double> > solver(control);
+    SolverCG<LinearAlgebra::distributed::Vector<double> > solver(control);
     solver.solve(fine_matrix, sol, in, preconditioner);
   }
 }
index 20484692cdc3dd11b9b35605fb7f3c24ad5b7ce8..38976a6666dac7184c50708226bfccbf2aa06f08 100644 (file)
@@ -37,7 +37,7 @@
 #include <deal.II/numerics/vector_tools.h>
 #include <deal.II/distributed/tria.h>
 
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/matrix_free/matrix_free.h>
 #include <deal.II/matrix_free/fe_evaluation.h>
 
@@ -62,17 +62,17 @@ namespace Step48
     SineGordonOperation(const MatrixFree<dim,double> &data_in,
                         const double                      time_step);
 
-    void apply (parallel::distributed::Vector<double>                        &dst,
-                const std::vector<parallel::distributed::Vector<double>*> &src) const;
+    void apply (LinearAlgebra::distributed::Vector<double>                        &dst,
+                const std::vector<LinearAlgebra::distributed::Vector<double>*> &src) const;
 
   private:
     const MatrixFree<dim,double>         &data;
     const VectorizedArray<double>         delta_t_sqr;
-    parallel::distributed::Vector<double> inv_mass_matrix;
+    LinearAlgebra::distributed::Vector<double> inv_mass_matrix;
 
     void local_apply (const MatrixFree<dim,double>               &data,
-                      parallel::distributed::Vector<double>      &dst,
-                      const std::vector<parallel::distributed::Vector<double>*> &src,
+                      LinearAlgebra::distributed::Vector<double>      &dst,
+                      const std::vector<LinearAlgebra::distributed::Vector<double>*> &src,
                       const std::pair<unsigned int,unsigned int> &cell_range) const;
   };
 
@@ -118,8 +118,8 @@ namespace Step48
   template <int dim, int fe_degree>
   void SineGordonOperation<dim, fe_degree>::
   local_apply (const MatrixFree<dim>                 &data,
-               parallel::distributed::Vector<double>     &dst,
-               const std::vector<parallel::distributed::Vector<double>*> &src,
+               LinearAlgebra::distributed::Vector<double>     &dst,
+               const std::vector<LinearAlgebra::distributed::Vector<double>*> &src,
                const std::pair<unsigned int,unsigned int> &cell_range) const
   {
     AssertDimension (src.size(), 2);
@@ -156,8 +156,8 @@ namespace Step48
 
   template <int dim, int fe_degree>
   void SineGordonOperation<dim, fe_degree>::
-  apply (parallel::distributed::Vector<double>                        &dst,
-         const std::vector<parallel::distributed::Vector<double>*> &src) const
+  apply (LinearAlgebra::distributed::Vector<double>                        &dst,
+         const std::vector<LinearAlgebra::distributed::Vector<double>*> &src) const
   {
     dst = 0;
     data.cell_loop (&SineGordonOperation<dim,fe_degree>::local_apply,
@@ -220,7 +220,7 @@ namespace Step48
 
     MatrixFree<dim,double> matrix_free_data;
 
-    parallel::distributed::Vector<double> solution, old_solution, old_old_solution;
+    LinearAlgebra::distributed::Vector<double> solution, old_solution, old_old_solution;
 
     const unsigned int n_global_refinements;
     double time, time_step;
@@ -360,7 +360,7 @@ namespace Step48
                               old_solution);
     output_results (0);
 
-    std::vector<parallel::distributed::Vector<double>*> previous_solutions;
+    std::vector<LinearAlgebra::distributed::Vector<double>*> previous_solutions;
     previous_solutions.push_back(&old_solution);
     previous_solutions.push_back(&old_old_solution);
 
index 99f46480a407459f3f18ab41ae8d040b2ababecf..57f2cb0c877c7052bb2311977a33d0032b80a77c 100644 (file)
@@ -33,7 +33,7 @@
 #include <deal.II/fe/fe_values.h>
 #include <deal.II/numerics/vector_tools.h>
 
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/matrix_free/matrix_free.h>
 #include <deal.II/matrix_free/fe_evaluation.h>
 
@@ -57,17 +57,17 @@ namespace Step48
     SineGordonOperation(const MatrixFree<dim,double> &data_in,
                         const double                      time_step);
 
-    void apply (parallel::distributed::Vector<double>                        &dst,
-                const std::vector<parallel::distributed::Vector<double>*> &src) const;
+    void apply (LinearAlgebra::distributed::Vector<double>                        &dst,
+                const std::vector<LinearAlgebra::distributed::Vector<double>*> &src) const;
 
   private:
     const MatrixFree<dim,double>         &data;
     const VectorizedArray<double>         delta_t_sqr;
-    parallel::distributed::Vector<double> inv_mass_matrix;
+    LinearAlgebra::distributed::Vector<double> inv_mass_matrix;
 
     void local_apply (const MatrixFree<dim,double>               &data,
-                      parallel::distributed::Vector<double>      &dst,
-                      const std::vector<parallel::distributed::Vector<double>*> &src,
+                      LinearAlgebra::distributed::Vector<double>      &dst,
+                      const std::vector<LinearAlgebra::distributed::Vector<double>*> &src,
                       const std::pair<unsigned int,unsigned int> &cell_range) const;
   };
 
@@ -113,8 +113,8 @@ namespace Step48
   template <int dim, int fe_degree>
   void SineGordonOperation<dim, fe_degree>::
   local_apply (const MatrixFree<dim>                 &data,
-               parallel::distributed::Vector<double>     &dst,
-               const std::vector<parallel::distributed::Vector<double>*> &src,
+               LinearAlgebra::distributed::Vector<double>     &dst,
+               const std::vector<LinearAlgebra::distributed::Vector<double>*> &src,
                const std::pair<unsigned int,unsigned int> &cell_range) const
   {
     AssertDimension (src.size(), 2);
@@ -164,8 +164,8 @@ namespace Step48
 
   template <int dim, int fe_degree>
   void SineGordonOperation<dim, fe_degree>::
-  apply (parallel::distributed::Vector<double>                        &dst,
-         const std::vector<parallel::distributed::Vector<double>*> &src) const
+  apply (LinearAlgebra::distributed::Vector<double>                        &dst,
+         const std::vector<LinearAlgebra::distributed::Vector<double>*> &src) const
   {
     dst = 0;
     data.cell_loop (&SineGordonOperation<dim,fe_degree>::local_apply,
@@ -214,7 +214,7 @@ namespace Step48
 
     MatrixFree<dim,double> matrix_free_data;
 
-    parallel::distributed::Vector<double> solution, old_solution, old_old_solution;
+    LinearAlgebra::distributed::Vector<double> solution, old_solution, old_old_solution;
 
     const unsigned int n_global_refinements;
     double time, time_step;
@@ -322,7 +322,7 @@ namespace Step48
                               old_solution);
     output_norm ();
 
-    std::vector<parallel::distributed::Vector<double>*> previous_solutions;
+    std::vector<LinearAlgebra::distributed::Vector<double>*> previous_solutions;
     previous_solutions.push_back(&old_solution);
     previous_solutions.push_back(&old_old_solution);
 
index 2a44a04b8bcc7892a2dd4c90186e9fe0a252fd6f..37737ac297e9595ea23a44937aeb9e67e4c444de 100644 (file)
@@ -37,7 +37,7 @@
 #include <deal.II/numerics/vector_tools.h>
 #include <deal.II/distributed/tria.h>
 
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/matrix_free/matrix_free.h>
 #include <deal.II/matrix_free/fe_evaluation.h>
 
@@ -62,17 +62,17 @@ namespace Step48
     SineGordonOperation(const MatrixFree<dim,double> &data_in,
                         const double                      time_step);
 
-    void apply (parallel::distributed::Vector<double>                        &dst,
-                const std::vector<parallel::distributed::Vector<double>*> &src) const;
+    void apply (LinearAlgebra::distributed::Vector<double>                        &dst,
+                const std::vector<LinearAlgebra::distributed::Vector<double>*> &src) const;
 
   private:
     const MatrixFree<dim,double>         &data;
     const VectorizedArray<double>         delta_t_sqr;
-    parallel::distributed::Vector<double> inv_mass_matrix;
+    LinearAlgebra::distributed::Vector<double> inv_mass_matrix;
 
     void local_apply (const MatrixFree<dim,double>               &data,
-                      parallel::distributed::Vector<double>      &dst,
-                      const std::vector<parallel::distributed::Vector<double>*> &src,
+                      LinearAlgebra::distributed::Vector<double>      &dst,
+                      const std::vector<LinearAlgebra::distributed::Vector<double>*> &src,
                       const std::pair<unsigned int,unsigned int> &cell_range) const;
   };
 
@@ -118,8 +118,8 @@ namespace Step48
   template <int dim, int fe_degree>
   void SineGordonOperation<dim, fe_degree>::
   local_apply (const MatrixFree<dim>                 &data,
-               parallel::distributed::Vector<double>     &dst,
-               const std::vector<parallel::distributed::Vector<double>*> &src,
+               LinearAlgebra::distributed::Vector<double>     &dst,
+               const std::vector<LinearAlgebra::distributed::Vector<double>*> &src,
                const std::pair<unsigned int,unsigned int> &cell_range) const
   {
     AssertDimension (src.size(), 2);
@@ -155,8 +155,8 @@ namespace Step48
 
   template <int dim, int fe_degree>
   void SineGordonOperation<dim, fe_degree>::
-  apply (parallel::distributed::Vector<double>                        &dst,
-         const std::vector<parallel::distributed::Vector<double>*> &src) const
+  apply (LinearAlgebra::distributed::Vector<double>                        &dst,
+         const std::vector<LinearAlgebra::distributed::Vector<double>*> &src) const
   {
     dst = 0;
     data.cell_loop (&SineGordonOperation<dim,fe_degree>::local_apply,
@@ -209,7 +209,7 @@ namespace Step48
 
     MatrixFree<dim,double> matrix_free_data;
 
-    parallel::distributed::Vector<double> solution, old_solution, old_old_solution;
+    LinearAlgebra::distributed::Vector<double> solution, old_solution, old_old_solution;
 
     const unsigned int n_global_refinements;
     double time, time_step;
@@ -331,7 +331,7 @@ namespace Step48
                               old_solution);
     output_results (0);
 
-    std::vector<parallel::distributed::Vector<double>*> previous_solutions;
+    std::vector<LinearAlgebra::distributed::Vector<double>*> previous_solutions;
     previous_solutions.push_back(&old_solution);
     previous_solutions.push_back(&old_old_solution);
 
index 61888f2355ddec3210545c3f75955de78015bc1f..abe2ffbf76c62428f6a70e8e5902b8843fb92adb 100644 (file)
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/dofs/dof_tools.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 
 #include <fstream>
 
index 1d69296cc79aa3bb4fdfde9f0872f0c0efcb448f..237bbf843686ef114705ca96312c6ceb205c6e58 100644 (file)
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/dofs/dof_tools.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 
 #include <fstream>
 
@@ -42,7 +42,7 @@ void test ()
   local_active[1].set_size(2*numproc);
   local_active[1].add_range(myid*2,myid*2+2);
 
-  parallel::distributed::BlockVector<double> v(2);
+  LinearAlgebra::distributed::BlockVector<double> v(2);
   v.block(0).reinit(local_active[0], complete_index_set(numproc), MPI_COMM_WORLD);
   v.block(1).reinit(local_active[1], complete_index_set(2*numproc), MPI_COMM_WORLD);
   v.collect_sizes();
index e76fda085d682df85c4639953562888fd6ac249e..4da9868d35e805da61e4fb7bb71a670dc6bfcf3b 100644 (file)
@@ -20,8 +20,8 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -46,8 +46,8 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant,
-                                          MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant,
+                                               MPI_COMM_WORLD);
 
   // set local values
   if (myid < 8)
@@ -63,7 +63,7 @@ void test ()
       AssertThrow (v(myid*2+1) == myid*4.0+2.0, ExcInternalError());
     }
 
-  parallel::distributed::BlockVector<double> w(3);
+  LinearAlgebra::distributed::BlockVector<double> w(3);
   for (unsigned int i=0; i<3; ++i)
     w.block(i) = v;
   w.collect_sizes();
@@ -121,7 +121,7 @@ void test ()
     const double norm_sqr = w.l2_norm() * w.l2_norm();
     AssertThrow (std::fabs(w * w - norm_sqr) < 1e-12,
                  ExcInternalError());
-    parallel::distributed::BlockVector<double> w2;
+    LinearAlgebra::distributed::BlockVector<double> w2;
     w2 = w;
     AssertThrow (std::fabs(w2 * w - norm_sqr) < 1e-12,
                  ExcInternalError());
@@ -138,7 +138,7 @@ void test ()
     bool allzero = w.all_zero();
     if (myid == 0)
       deallog << " v==0 ? " << allzero << std::endl;
-    parallel::distributed::BlockVector<double> w2;
+    LinearAlgebra::distributed::BlockVector<double> w2;
     w2.reinit (w);
     allzero = w2.all_zero();
     if (myid == 0)
index e90bcd8b043d4aee9ad2fee00336a7e23d422faa..0007eda4ffac645aeaf23cd041b37111333aed1a 100644 (file)
@@ -19,8 +19,8 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_block_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -43,8 +43,8 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant,
-                                          MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant,
+                                               MPI_COMM_WORLD);
 
   // set local values
   if (myid < 8)
@@ -54,7 +54,7 @@ void test ()
     }
   v.compress(VectorOperation::insert);
 
-  parallel::distributed::BlockVector<double> w(3);
+  LinearAlgebra::distributed::BlockVector<double> w(3);
   for (unsigned int i=0; i<3; ++i)
     {
       w.block(i) = v;
@@ -95,7 +95,7 @@ void test ()
 
   // create a vector copy that gets the entries from w. First, it should not
   // have updated the ghosts because it is created from an empty state.
-  parallel::distributed::BlockVector<double> x(w);
+  LinearAlgebra::distributed::BlockVector<double> x(w);
   Assert(x.has_ghost_elements() == false, ExcInternalError());
   for (unsigned int i=0; i<3; ++i)
     if (myid == 0)
index 1ceb26b976e0b8269bda53c096db33cbbb64e3e9..1ef0f987c29b382a440ead1e5405deafaa283707 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -38,7 +38,7 @@ void test ()
   IndexSet local_owned(numproc*2);
   local_owned.add_range(myid*2,myid*2+2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_owned, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_owned, MPI_COMM_WORLD);
 
   // set local values
   v(myid*2)=myid*2.0;
index 709e50ac9c1df21b5b67aede30a649f00e66c790..815ca491564344efbd1c350cf67b911a014a3eb2 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -41,7 +41,7 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   // set local values and check them
   v(myid*2)=myid*2.0;
index 75a2e1e43826de625f867b6b1a8c34d292516f57..b45e6dee994063a6969fa40022fe93332c178737 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -41,7 +41,7 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   // set local values and check them
   v(myid*2)=myid*2.0;
index 161a944a8303cf9aee8d6e73b8f21cd09377974d..e893fd1b9795cdff5431a4e8deafc54e135af455 100644 (file)
@@ -20,7 +20,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -42,7 +42,7 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   // set local values and check them
   v(myid*2)=myid*2.0;
index 8c940956f14c71010ce458d48f3f13b88e55767a..02cfce54ed2cedb67e56d13945c28d0aaf96f795 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -41,7 +41,7 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   // set local values and check them
   v(myid*2)=myid*2.0;
index 0ad8c1e430eb2566b742716142900a25d38a3f2f..83e3a1c025084a7dcfb92bd912397bc49295c70d 100644 (file)
@@ -20,7 +20,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -45,7 +45,7 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_owned, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_owned, MPI_COMM_WORLD);
 
   // set local values
   if (myid < 8)
@@ -108,7 +108,7 @@ void test ()
     const double norm_sqr = v.l2_norm() * v.l2_norm();
     AssertThrow (std::fabs(v * v - norm_sqr) < 1e-15,
                  ExcInternalError());
-    parallel::distributed::Vector<double> v2;
+    LinearAlgebra::distributed::Vector<double> v2;
     v2 = v;
     AssertThrow (std::fabs(v2 * v - norm_sqr) < 1e-15,
                  ExcInternalError());
@@ -125,7 +125,7 @@ void test ()
     bool allzero = v.all_zero();
     if (myid == 0)
       deallog << " v==0 ? " << allzero << std::endl;
-    parallel::distributed::Vector<double> v2;
+    LinearAlgebra::distributed::Vector<double> v2;
     v2.reinit (v);
     allzero = v2.all_zero();
     if (myid == 0)
index b31dfd46d0be4363bfbf9e223c6681d7eb16769c..6f79349bdee1715cb25534b58d90f629eadf0755 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -57,7 +57,7 @@ void test ()
                                     };
   local_relevant.add_indices (&ghost_indices[0], &ghost_indices[0]+10);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   // set a few of the local elements
   for (unsigned i=0; i<local_size; ++i)
index 931cc4926cc636baa64cb4a971659f8bf6985f1c..e26a5464fea104ab7e31f271a30245491bc0cadb 100644 (file)
@@ -20,7 +20,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -61,8 +61,8 @@ void test ()
   // v has ghosts, w has none. set some entries
   // on w, copy into v and check if they are
   // there
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
-  parallel::distributed::Vector<double> w(local_owned, local_owned, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> w(local_owned, local_owned, MPI_COMM_WORLD);
 
   // set a few of the local elements
   for (unsigned i=0; i<local_size; ++i)
index 0da7eba172aac3de2712d2d2b904f42266a951ef..35c9dd79a0a77be5631df658ba1ea08cb77f6677 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -57,7 +57,7 @@ void test ()
                                     };
   local_relevant.add_indices (&ghost_indices[0], &ghost_indices[0]+10);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   // check number of ghosts everywhere (counted
   // the above)
index 3dcbb463f47f6bb9b9b0362e989cef0be638ad61..7dc8da68fcbf873ba6c963e96f2912e212037bb4 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -41,8 +41,8 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
-  parallel::distributed::Vector<double> w(v);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> w(v);
 
   // set local values and check them
   v(myid*2)=myid*2.0;
index e9bc30d53e8276572cd7bab3bf46eded3d39ec6a..21b5dc5405f599c97a88df885161882119c87788 100644 (file)
@@ -20,7 +20,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -49,10 +49,10 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_index (2);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant,
-                                          MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant,
+                                               MPI_COMM_WORLD);
   AssertDimension (static_cast<unsigned int>(actual_local_size), v.local_size());
-  parallel::distributed::Vector<double> w (v), x(v), y(v);
+  LinearAlgebra::distributed::Vector<double> w (v), x(v), y(v);
 
   // set local elements
   for (int i=0; i<actual_local_size; ++i)
@@ -155,7 +155,7 @@ void test ()
   if (myid==0) deallog << "OK" << std::endl;
 
   if (myid==0) deallog << "Check equ<float> (factor, vector): ";
-  parallel::distributed::Vector<float> z;
+  LinearAlgebra::distributed::Vector<float> z;
   z = v;
   y = z;
   for (int i=0; i<actual_local_size; ++i)
index 54545b555b8a7669183c1ecf3a7cb7faaf8785be..3af22c2e44d3aa50b56a53d847a324e79f90c73b 100644 (file)
 // ---------------------------------------------------------------------
 
 
-// check parallel::distributed::Vector::swap
+// check LinearAlgebra::distributed::Vector::swap
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -54,8 +54,8 @@ void test ()
   if (numproc > 2)
     local_relevant0.add_index(8);
 
-  parallel::distributed::Vector<double> v0(local_owned0, local_relevant0,
-                                           MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v0(local_owned0, local_relevant0,
+                                                MPI_COMM_WORLD);
 
   // vector1: local size 4
   const unsigned int local_size1 = 4;
@@ -76,8 +76,8 @@ void test ()
       local_relevant1.add_index(10);
     }
 
-  parallel::distributed::Vector<double> v1(local_owned1, local_relevant1,
-                                           MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v1(local_owned1, local_relevant1,
+                                                MPI_COMM_WORLD);
 
   v0 = 1;
   v1 = 2;
@@ -147,7 +147,7 @@ void test ()
   if (myid==0) deallog << "Ghost values after re-set OK" << std::endl;
 
   // swap with an empty vector
-  parallel::distributed::Vector<double> v2;
+  LinearAlgebra::distributed::Vector<double> v2;
   v2.swap (v0);
   AssertDimension (v0.size(), 0);
   AssertDimension (v2.size(), global_size1);
index 75f69f7a573a08b38f7c6acc4d9e4531b99b2ac1..0d530d3d00a77e67811f4c5ee0c07875120d560f 100644 (file)
@@ -21,7 +21,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -44,7 +44,7 @@ void test ()
   local_relevant.add_range(1,2);
   local_relevant.add_range(4,5);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   // set local values and check them
   v(myid*2)=myid*2.0;
index 23ea2c68f0d2e217da6d0aaf7fb8ff61ed8ce28a..5ed1452a92d48c0809724d828f1e6c896abfd94e 100644 (file)
@@ -20,7 +20,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -49,7 +49,7 @@ void test ()
   // and once where they have not
   for (unsigned int run = 0; run < 2; ++run)
     {
-      parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+      LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
       // set local values
       if (myid < 2)
@@ -60,7 +60,7 @@ void test ()
 
       v.compress(VectorOperation::insert);
 
-      parallel::distributed::Vector<double> w(v), u(v);
+      LinearAlgebra::distributed::Vector<double> w(v), u(v);
       u = 0;
 
       v*=2.0;
@@ -80,8 +80,8 @@ void test ()
         }
 
       // copy vector content to non-ghosted vectors, manually created.
-      parallel::distributed::Vector<double> v_dist(local_owned, MPI_COMM_WORLD),
-               w_dist(v_dist), u_dist(v_dist);
+      LinearAlgebra::distributed::Vector<double> v_dist(local_owned, MPI_COMM_WORLD),
+                    w_dist(v_dist), u_dist(v_dist);
 
       v_dist = v;
       w_dist = w;
index 2aa6b8b942239ead1a301c348ac5227a6c3352c0..2b3f4be7b194c2bea589d324ec1b7789e0b4ba12 100644 (file)
@@ -21,7 +21,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -45,7 +45,7 @@ void test ()
   if (numproc > 1)
     local_relevant.add_range(3,4);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   // set local values
   if (myid < 2)
@@ -59,7 +59,7 @@ void test ()
   if (myid==0)
     deallog << "v has ghost elements: " << v.has_ghost_elements() << std::endl;
 
-  parallel::distributed::Vector<double> w, x;
+  LinearAlgebra::distributed::Vector<double> w, x;
   w = v;
   if (myid==0)
     deallog << "w has ghost elements: " << w.has_ghost_elements() << std::endl;
index c6d0eeefa04048f0e1ffbc0b23a6fe8a30c4de8d..5e15c24c5338ded3a73908f94bc27f9585edd4a5 100644 (file)
@@ -22,7 +22,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -47,7 +47,7 @@ void test ()
   local_relevant.add_range(min_index+38,min_index+40);
   local_relevant.add_range(min_index+41,min_index+43);
 
-  parallel::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v(local_owned, local_relevant, MPI_COMM_WORLD);
 
   deallog << "Local range of proc 0: " << v.local_range().first << " "
           << v.local_range().second << std::endl;
index 5146d6fec8e2fc8f20a1c6a4abd41a8d30796103..aa74ecfe53ba93005a247814ca3b4dc90aa3179d 100644 (file)
 // ---------------------------------------------------------------------
 
 
-// check parallel::distributed::Vector::partitioners_are_compatible and
+// check LinearAlgebra::distributed::Vector::partitioners_are_compatible and
 // partitioners_are_globally_compatible
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -41,7 +41,7 @@ void test ()
   local_relevant = local_owned;
   local_relevant.add_range(1,2);
 
-  parallel::distributed::Vector<double> v1, v2, v3, v4, v5, v6;
+  LinearAlgebra::distributed::Vector<double> v1, v2, v3, v4, v5, v6;
   v1.reinit(local_owned, MPI_COMM_WORLD);
   v2.reinit(local_owned, local_relevant, MPI_COMM_WORLD);
   v3.reinit(local_owned, local_relevant, MPI_COMM_WORLD);
index e4a4fd37379376491dff8a9fe428ecf8454827ff..97ac8f6d40d4c980957e0068086873298c93a65f 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/constraint_matrix.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
@@ -58,7 +58,7 @@ void test ()
   DoFTools::extract_locally_relevant_dofs (dof2,
                                            locally_relevant_dofs2);
 
-  parallel::distributed::Vector<double>
+  LinearAlgebra::distributed::Vector<double>
   v2(dof2.locally_owned_dofs(), locally_relevant_dofs2, MPI_COMM_WORLD),
   v2_interpolated(v2);
 
index c79730a3d013211e3144fea61efe5857c0483a9d..c80f19e575751610b087df1d7e9033ec11b13d79 100644 (file)
@@ -19,7 +19,7 @@
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
 #include <deal.II/base/index_set.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/dofs/dof_handler.h>
@@ -52,10 +52,10 @@ void test ()
   DoFTools::extract_locally_relevant_dofs (dof2,
                                            locally_relevant_dofs2);
 
-  parallel::distributed::Vector<double> v1(dof1.locally_owned_dofs(),
-                                           locally_relevant_dofs1,
-                                           MPI_COMM_WORLD),
-                                           v2(dof2.locally_owned_dofs(), locally_relevant_dofs2, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> v1(dof1.locally_owned_dofs(),
+                                                locally_relevant_dofs1,
+                                                MPI_COMM_WORLD),
+                                                v2(dof2.locally_owned_dofs(), locally_relevant_dofs2, MPI_COMM_WORLD);
 
   // set first vector to 1
   VectorTools::interpolate(dof1, ConstantFunction<dim>(1.), v1);
index e682835cf83a5a81f0a0de9037c8fa07c3a60596..76e2e306d14aabf47890b73745ac08bc2260deb3 100644 (file)
@@ -23,7 +23,7 @@
 #include <deal.II/base/conditional_ostream.h>
 #include <deal.II/base/index_set.h>
 
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/grid/tria_accessor.h>
@@ -58,7 +58,7 @@ void test()
   dof_handler.distribute_dofs (fe);
 
   IndexSet locally_owned_dofs = dof_handler.locally_owned_dofs ();
-  parallel::distributed::Vector<double> locally_owned_solution
+  LinearAlgebra::distributed::Vector<double> locally_owned_solution
   (locally_owned_dofs, MPI_COMM_WORLD);
 
   locally_owned_solution=1;
index e8020c6d83d91cb222f6ab5ad0ae76415a400322..a9438b3cc2e9adef3dd4b16b4ce604a0220be53a 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -92,7 +92,7 @@ void test ()
   x.reinit (col_partitioning, MPI_COMM_WORLD);
   y.reinit (row_partitioning, MPI_COMM_WORLD);
 
-  parallel::distributed::Vector<double>
+  LinearAlgebra::distributed::Vector<double>
   dx (col_partitioning, col_partitioning, MPI_COMM_WORLD),
   dy (row_partitioning, row_partitioning, MPI_COMM_WORLD);
 
index 3113685470a23c9435347858f25f79a0f8c9d5c8..77c573f702ce4dee33783ff49b75950514424ce0 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -92,7 +92,7 @@ void test ()
   x.reinit (col_partitioning, MPI_COMM_WORLD);
   y.reinit (row_partitioning, MPI_COMM_WORLD);
 
-  parallel::distributed::Vector<double>
+  LinearAlgebra::distributed::Vector<double>
   dx (col_partitioning, col_partitioning, MPI_COMM_WORLD),
   dy (row_partitioning, row_partitioning, MPI_COMM_WORLD);
 
index d6f7970e0626222a6f09caa25797feaeb5ad9883..60319da74f90c4d5053656130c9a897c6a10ea31 100644 (file)
@@ -25,7 +25,7 @@
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
@@ -86,7 +86,7 @@ void test ()
   x.reinit (col_partitioning, MPI_COMM_WORLD);
   y.reinit (row_partitioning, MPI_COMM_WORLD);
 
-  parallel::distributed::Vector<double>
+  LinearAlgebra::distributed::Vector<double>
   dx (col_partitioning, col_partitioning, MPI_COMM_WORLD),
   dy (row_partitioning, row_partitioning, MPI_COMM_WORLD);
 
index 17996eaa7b49aa5dd16634e4f15df3f000693205..962df7ae047dd8ada4200b6fa102cfe674b3663c 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
index ae8ee3dda60c5c63f703f04272eb5b313ecc8163..beaf52cab09ca54a50dabce53183787c51d93143 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
index 466671164e732a5640ea99d29ecca9abed751afa..32f0e915137daa91b8ccaf6fec86c5bad84899cc 100644 (file)
@@ -23,7 +23,7 @@
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
index 387b4f8c95641efa20ab7f9a5b6184688ff754c4..223e55d696b7f508999ea5599c4956f6449d03ff 100644 (file)
@@ -24,7 +24,7 @@
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
index 3586b44708b58ddcfa03c74ce62898858eb98b0c..6b14a7501cdc78e128bc7dbda48518ee4121474e 100644 (file)
@@ -27,7 +27,7 @@
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <deal.II/lac/trilinos_sparsity_pattern.h>
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
index c6c7d77f6c0f15c4a4fc7df724fe07abd6b5320a..65b4d650716fd3edfe975377ec21bd8cd14e579d 100644 (file)
@@ -14,7 +14,7 @@
 // ---------------------------------------------------------------------
 
 // Similar to step-16-03 (starting the mg hierarchy at level 2 rather than
-// level 0) but for parallel::distributed::Vector that has a different code
+// level 0) but for LinearAlgebra::distributed::Vector that has a different code
 // path
 
 #include "../tests.h"
@@ -27,7 +27,7 @@
 #include <deal.II/base/mpi.h>
 
 #include <deal.II/lac/constraint_matrix.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/full_matrix.h>
 #include <deal.II/lac/sparse_matrix.h>
 #include <deal.II/lac/solver_cg.h>
@@ -85,8 +85,8 @@ private:
   ConstraintMatrix     hanging_node_constraints;
   ConstraintMatrix     constraints;
 
-  parallel::distributed::Vector<double> solution;
-  parallel::distributed::Vector<double> system_rhs;
+  LinearAlgebra::distributed::Vector<double> solution;
+  LinearAlgebra::distributed::Vector<double> system_rhs;
 
   const unsigned int degree;
   const unsigned int min_level;
@@ -371,20 +371,20 @@ void LaplaceProblem<dim>::assemble_multigrid ()
 template <int dim>
 void LaplaceProblem<dim>::solve ()
 {
-  MGTransferPrebuilt<parallel::distributed::Vector<double> >
+  MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >
   mg_transfer(hanging_node_constraints, mg_constrained_dofs);
   mg_transfer.build_matrices(mg_dof_handler);
 
   SolverControl coarse_solver_control (1000, 1e-10, false, false);
-  SolverCG<parallel::distributed::Vector<double> > coarse_solver(coarse_solver_control);
+  SolverCG<LinearAlgebra::distributed::Vector<double> > coarse_solver(coarse_solver_control);
   PreconditionIdentity id;
-  MGCoarseGridLACIteration<SolverCG<parallel::distributed::Vector<double> >,parallel::distributed::Vector<double> >
+  MGCoarseGridLACIteration<SolverCG<LinearAlgebra::distributed::Vector<double> >,LinearAlgebra::distributed::Vector<double> >
   coarse_grid_solver(coarse_solver, mg_matrices[min_level], id);
   deallog << "   Size of coarse grid matrix: " << mg_matrices[min_level].m() << std::endl;
 
-  typedef PreconditionChebyshev<SparseMatrix<double>,parallel::distributed::Vector<double> > Smoother;
-  GrowingVectorMemory<parallel::distributed::Vector<double> >   vector_memory;
-  MGSmootherPrecondition<SparseMatrix<double>, Smoother, parallel::distributed::Vector<double> >
+  typedef PreconditionChebyshev<SparseMatrix<double>,LinearAlgebra::distributed::Vector<double> > Smoother;
+  GrowingVectorMemory<LinearAlgebra::distributed::Vector<double> >   vector_memory;
+  MGSmootherPrecondition<SparseMatrix<double>, Smoother, LinearAlgebra::distributed::Vector<double> >
   mg_smoother;
   typename Smoother::AdditionalData smoother_data;
   smoother_data.smoothing_range = 20.;
@@ -392,24 +392,24 @@ void LaplaceProblem<dim>::solve ()
   smoother_data.eig_cg_n_iterations = 20;
   mg_smoother.initialize(mg_matrices, smoother_data);
 
-  mg::Matrix<parallel::distributed::Vector<double> > mg_matrix(mg_matrices);
-  mg::Matrix<parallel::distributed::Vector<double> > mg_interface_up(mg_interface_matrices);
-  mg::Matrix<parallel::distributed::Vector<double> > mg_interface_down(mg_interface_matrices);
-
-  Multigrid<parallel::distributed::Vector<double> > mg(min_level,
-                                                       triangulation.n_global_levels()-1,
-                                                       mg_matrix,
-                                                       coarse_grid_solver,
-                                                       mg_transfer,
-                                                       mg_smoother,
-                                                       mg_smoother);
+  mg::Matrix<LinearAlgebra::distributed::Vector<double> > mg_matrix(mg_matrices);
+  mg::Matrix<LinearAlgebra::distributed::Vector<double> > mg_interface_up(mg_interface_matrices);
+  mg::Matrix<LinearAlgebra::distributed::Vector<double> > mg_interface_down(mg_interface_matrices);
+
+  Multigrid<LinearAlgebra::distributed::Vector<double> > mg(min_level,
+                                                            triangulation.n_global_levels()-1,
+                                                            mg_matrix,
+                                                            coarse_grid_solver,
+                                                            mg_transfer,
+                                                            mg_smoother,
+                                                            mg_smoother);
   mg.set_edge_matrices(mg_interface_down, mg_interface_up);
 
-  PreconditionMG<dim, parallel::distributed::Vector<double>, MGTransferPrebuilt<parallel::distributed::Vector<double> > >
+  PreconditionMG<dim, LinearAlgebra::distributed::Vector<double>, MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> > >
   preconditioner(mg_dof_handler, mg, mg_transfer);
 
   SolverControl solver_control (1000, 1e-12);
-  SolverCG<parallel::distributed::Vector<double> > cg (solver_control);
+  SolverCG<LinearAlgebra::distributed::Vector<double> > cg (solver_control);
 
   solution = 0;
 
index 99043dde5bcf62bb5a38d75c3588cf312c8b244c..22980e61ae7df84c23a8e43863fa90c2ccafb3d1 100644 (file)
@@ -19,7 +19,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/fe/fe_q.h>
@@ -70,7 +70,7 @@ void check(const unsigned int fe_degree)
       mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
 
       // build reference
-      MGTransferPrebuilt<parallel::distributed::Vector<double> >
+      MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >
       transfer_ref(hanging_node_constraints, mg_constrained_dofs);
       transfer_ref.build_matrices(mgdof);
 
@@ -81,8 +81,8 @@ void check(const unsigned int fe_degree)
       // check prolongation for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
@@ -99,8 +99,8 @@ void check(const unsigned int fe_degree)
       // check restriction for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
index 475eadf04c7f2a7244714c412a47bb3400312fcd..2aa638c5cda46b562d92781550942dd139c759cf 100644 (file)
@@ -19,7 +19,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/dofs/dof_tools.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
@@ -96,7 +96,7 @@ void check(const unsigned int fe_degree)
       mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
 
       // build reference
-      MGTransferPrebuilt<parallel::distributed::Vector<double> >
+      MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >
       transfer_ref(hanging_node_constraints, mg_constrained_dofs);
       transfer_ref.build_matrices(mgdof);
 
@@ -107,8 +107,8 @@ void check(const unsigned int fe_degree)
       // check prolongation for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
@@ -125,8 +125,8 @@ void check(const unsigned int fe_degree)
       // check restriction for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
index 4ae35320e21cb0c9ae99b0eee6801ea7894357d5..63dfee45d9206fd2d577af815bc936d5361b90f1 100644 (file)
@@ -20,7 +20,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/dofs/dof_tools.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
@@ -73,7 +73,7 @@ void check(const unsigned int fe_degree)
       mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
 
       // build reference
-      MGTransferPrebuilt<parallel::distributed::Vector<double> >
+      MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >
       transfer_ref(hanging_node_constraints, mg_constrained_dofs);
       transfer_ref.build_matrices(mgdof);
 
@@ -84,8 +84,8 @@ void check(const unsigned int fe_degree)
       // check prolongation for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
@@ -102,8 +102,8 @@ void check(const unsigned int fe_degree)
       // check restriction for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
index c85ea33c289a6f5d2c33dcc173f60fb814d9a406..ed8c5f8e22ef4e97438b17ec56abf72f5c426f80 100644 (file)
@@ -20,7 +20,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/fe/fe_dgq.h>
@@ -64,7 +64,7 @@ void check(const unsigned int fe_degree)
       mgdof.distribute_mg_dofs(fe);
 
       // build reference
-      MGTransferPrebuilt<parallel::distributed::Vector<double> > transfer_ref;
+      MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> > transfer_ref;
       transfer_ref.build_matrices(mgdof);
 
       // build matrix-free transfer
@@ -74,8 +74,8 @@ void check(const unsigned int fe_degree)
       // check prolongation for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
@@ -92,8 +92,8 @@ void check(const unsigned int fe_degree)
       // check restriction for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
index 7fdda041d57eb0b709e242e34ec95dd9a465548c..433c5fa3ce0942b11aae7762539586ac7c0f72e8 100644 (file)
@@ -20,7 +20,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
 #include <deal.II/fe/fe_dgq.h>
@@ -83,7 +83,7 @@ void check(const unsigned int fe_degree)
       mgdof.distribute_mg_dofs(fe);
 
       // build reference
-      MGTransferPrebuilt<parallel::distributed::Vector<double> > transfer_ref;
+      MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> > transfer_ref;
       transfer_ref.build_matrices(mgdof);
 
       // build matrix-free transfer
@@ -93,8 +93,8 @@ void check(const unsigned int fe_degree)
       // check prolongation for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
@@ -111,8 +111,8 @@ void check(const unsigned int fe_degree)
       // check restriction for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
index acb60f93fd0406c6990fc2a4d9945f639b244129..a27626bc8c9a6a59f4512d5be3c806c61972465e 100644 (file)
@@ -20,7 +20,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/dofs/dof_tools.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
@@ -98,7 +98,7 @@ void check(const unsigned int fe_degree)
       mg_constrained_dofs.initialize(mgdof, dirichlet_boundary);
 
       // build reference
-      MGTransferPrebuilt<parallel::distributed::Vector<double> >
+      MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >
       transfer_ref(hanging_node_constraints, mg_constrained_dofs);
       transfer_ref.build_matrices(mgdof);
 
@@ -109,8 +109,8 @@ void check(const unsigned int fe_degree)
       // check prolongation for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
@@ -127,8 +127,8 @@ void check(const unsigned int fe_degree)
       // check restriction for all levels using random vector
       for (unsigned int level=1; level<mgdof.get_triangulation().n_global_levels(); ++level)
         {
-          parallel::distributed::Vector<Number> v1, v2;
-          parallel::distributed::Vector<double> v1_cpy, v2_cpy, v3;
+          LinearAlgebra::distributed::Vector<Number> v1, v2;
+          LinearAlgebra::distributed::Vector<double> v1_cpy, v2_cpy, v3;
           v1.reinit(mgdof.locally_owned_mg_dofs(level), MPI_COMM_WORLD);
           v2.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
           v3.reinit(mgdof.locally_owned_mg_dofs(level-1), MPI_COMM_WORLD);
index b59d9ef4aa27b02cea636355ce52db2a55a57ed4..15e61789e00234004d2ae931c5d9c39930b5eef0 100644 (file)
@@ -21,7 +21,7 @@
 
 #include "../tests.h"
 #include <deal.II/base/logstream.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/dofs/dof_tools.h>
 #include <deal.II/distributed/tria.h>
 #include <deal.II/grid/grid_generator.h>
@@ -84,7 +84,7 @@ void check()
           grid_out.write_svg (tr, grid_output);
         }
 
-      MGTransferPrebuilt<parallel::distributed::Vector<double> >
+      MGTransferPrebuilt<LinearAlgebra::distributed::Vector<double> >
       transfer_ref(hanging_node_constraints, mg_constrained_dofs);
       transfer_ref.build_matrices(mgdof);
     }
index 3e1c7dbad3c19237976084929d1c1954327b4928..c76e21268b3abfcd7117addefb3f328b65a01aee 100644 (file)
 
 
 
-// Test parallel::distributed::Vector::operator=(PETScWrappers::MPI::Vector&)
+// Test LinearAlgebra::distributed::Vector::operator=(PETScWrappers::MPI::Vector&)
 
 #include "../tests.h"
 #include <deal.II/lac/petsc_parallel_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/base/index_set.h>
 #include <fstream>
 #include <iostream>
@@ -46,7 +46,7 @@ void test ()
   PETScWrappers::MPI::Vector vb(local_active, MPI_COMM_WORLD);
   PETScWrappers::MPI::Vector v(local_active, local_relevant, MPI_COMM_WORLD);
 
-  parallel::distributed::Vector<double> copied(local_active, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> copied(local_active, local_relevant, MPI_COMM_WORLD);
 
   // set local values
   vb(myid*2)=myid*2.0;
index af52deb2ed8e7d44cde46421f795195ccde8e552..2cccd11711fc8ccd2f975cb3e06058a6a005ac56 100644 (file)
 
 
 
-// Test parallel::distributed::Vector::operator=(PETScWrappers::MPI::BlockVector&)
+// Test LinearAlgebra::distributed::Vector::operator=(PETScWrappers::MPI::BlockVector&)
 
 #include "../tests.h"
 #include <deal.II/lac/petsc_parallel_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/base/index_set.h>
 #include <fstream>
@@ -48,7 +48,7 @@ void test ()
   PETScWrappers::MPI::Vector vb_one(local_active, MPI_COMM_WORLD);
   PETScWrappers::MPI::Vector v_one(local_active, local_relevant, MPI_COMM_WORLD);
 
-  parallel::distributed::Vector<double> copied_one(local_active, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> copied_one(local_active, local_relevant, MPI_COMM_WORLD);
 
   // set local values
   vb_one(myid*2)=myid*2.0;
@@ -61,7 +61,7 @@ void test ()
   PETScWrappers::MPI::BlockVector vb, v;
   vb.reinit(2);
   v.reinit(2);
-  parallel::distributed::BlockVector<double> copied(2);
+  LinearAlgebra::distributed::BlockVector<double> copied(2);
   for (unsigned int bl=0; bl<2; ++bl)
     {
       vb.block(bl) = vb_one;
index bdd58ede8cc870bf548b40a63167afb31ed27550..b3081b998b84bdec77750ee2ba6f9ba54d56c629 100644 (file)
@@ -43,7 +43,7 @@
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
 
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 
 #include <deal.II/distributed/tria.h>
 #include <deal.II/distributed/grid_refinement.h>
@@ -84,8 +84,8 @@ void test ()
   DoFTools::extract_locally_relevant_dofs (dof_handler,locally_relevant_dofs);
 
   PETScWrappers::MPI::Vector vector, vector_locally_relevant;
-  parallel::distributed::Vector< double > vector_Re, vector_Re_locally_relevant,
-           vector_Im, vector_Im_locally_relevant;
+  LinearAlgebra::distributed::Vector< double > vector_Re, vector_Re_locally_relevant,
+                vector_Im, vector_Im_locally_relevant;
   vector.reinit(locally_owned_dofs, mpi_communicator);
   vector_locally_relevant.reinit (locally_owned_dofs,
                                   locally_relevant_dofs,mpi_communicator);
index 2b98057cc1169f292a2c74d4dc25e47fa8133288..beee564d8bf08fcb2a43639d8300dcbda91e86ff 100644 (file)
 
 
 
-// Test parallel::distributed::Vector::operator=(TrilinosWrappers::MPI::Vector&)
+// Test LinearAlgebra::distributed::Vector::operator=(TrilinosWrappers::MPI::Vector&)
 
 #include "../tests.h"
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/base/index_set.h>
 #include <fstream>
 #include <iostream>
@@ -46,7 +46,7 @@ void test ()
   TrilinosWrappers::MPI::Vector vb(local_active, MPI_COMM_WORLD);
   TrilinosWrappers::MPI::Vector v(local_active, local_relevant, MPI_COMM_WORLD);
 
-  parallel::distributed::Vector<double> copied(local_active, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> copied(local_active, local_relevant, MPI_COMM_WORLD);
 
   // set local values
   vb(myid*2)=myid*2.0;
@@ -72,7 +72,7 @@ void test ()
   Assert(copied(myid*2) == myid*4.0, ExcInternalError());
   Assert(copied(myid*2+1) == myid*4.0+2.0, ExcInternalError());
 
-  copied = v;
+  copied.update_ghost_values();
 
   // check ghost values
   if (Utilities::MPI::this_mpi_process (MPI_COMM_WORLD) == 0)
index 2152ae255fbe12561a8d1097c89a20904f59f8d5..34900c67b4ac2f50deeb701113b27aeacbd87896 100644 (file)
 
 
 
-// Test parallel::distributed::Vector::operator=(TrilinosWrappers::MPI::BlockVector&)
+// Test LinearAlgebra::distributed::Vector::operator=(TrilinosWrappers::MPI::BlockVector&)
 
 #include "../tests.h"
 #include <deal.II/lac/trilinos_vector.h>
-#include <deal.II/lac/parallel_vector.h>
-#include <deal.II/lac/parallel_block_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
+#include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_parallel_block_vector.h>
 #include <deal.II/base/index_set.h>
 #include <fstream>
@@ -48,7 +48,7 @@ void test ()
   TrilinosWrappers::MPI::Vector vb_one(local_active, MPI_COMM_WORLD);
   TrilinosWrappers::MPI::Vector v_one(local_active, local_relevant, MPI_COMM_WORLD);
 
-  parallel::distributed::Vector<double> copied_one(local_active, local_relevant, MPI_COMM_WORLD);
+  LinearAlgebra::distributed::Vector<double> copied_one(local_active, local_relevant, MPI_COMM_WORLD);
 
   // set local values
   vb_one(myid*2)=myid*2.0;
@@ -59,7 +59,7 @@ void test ()
   v_one=vb_one;
 
   TrilinosWrappers::MPI::BlockVector vb(2), v(2);
-  parallel::distributed::BlockVector<double> copied(2);
+  LinearAlgebra::distributed::BlockVector<double> copied(2);
   for (unsigned int bl=0; bl<2; ++bl)
     {
       vb.block(bl) = vb_one;
index f6e782b7ba7160a0d6bd1de4849649313ab9aace..87c7c9ec84585d71ff54c44892a90289b7a1ac84 100644 (file)
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (parallel::distributed::Vector<double> &v,
-           parallel::distributed::Vector<double> &w)
+void test (LinearAlgebra::distributed::Vector<double> &v,
+           LinearAlgebra::distributed::Vector<double> &w)
 {
   TrilinosWrappers::SparseMatrix m(w.size(),v.size(),v.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -79,8 +79,8 @@ int main (int argc, char **argv)
   try
     {
       {
-        parallel::distributed::Vector<double> v (100);
-        parallel::distributed::Vector<double> w (95);
+        LinearAlgebra::distributed::Vector<double> v (100);
+        LinearAlgebra::distributed::Vector<double> w (95);
         test (v,w);
       }
     }
index b3734eb82da2e65bd51a389bd19f8a896fea6b79..592b8b840c1d85ce35eee1968a60e0125893be2f 100644 (file)
 
 #include "../tests.h"
 #include <deal.II/base/utilities.h>
-#include <deal.II/lac/parallel_vector.h>
+#include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/trilinos_sparse_matrix.h>
 #include <fstream>
 #include <iostream>
 #include <vector>
 
 
-void test (parallel::distributed::Vector<double> &v,
-           parallel::distributed::Vector<double> &w)
+void test (LinearAlgebra::distributed::Vector<double> &v,
+           LinearAlgebra::distributed::Vector<double> &w)
 {
   TrilinosWrappers::SparseMatrix m(v.size(),w.size(),w.size());
   for (unsigned int i=0; i<m.m(); ++i)
@@ -78,8 +78,8 @@ int main (int argc, char **argv)
   try
     {
       {
-        parallel::distributed::Vector<double> v (95);
-        parallel::distributed::Vector<double> w (100);
+        LinearAlgebra::distributed::Vector<double> v (95);
+        LinearAlgebra::distributed::Vector<double> w (100);
         test (v,w);
       }
     }

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.