]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Remove deprecated PETSc vector classes.
authorDavid Wells <wellsd2@rpi.edu>
Thu, 4 May 2017 00:52:10 +0000 (20:52 -0400)
committerDavid Wells <wellsd2@rpi.edu>
Thu, 4 May 2017 01:45:41 +0000 (21:45 -0400)
55 files changed:
cmake/config/template-arguments.in
examples/step-36/step-36.cc
include/deal.II/fe/fe_tools_extrapolate.templates.h
include/deal.II/fe/fe_tools_interpolate.templates.h
include/deal.II/lac/constraint_matrix.templates.h
include/deal.II/lac/petsc_block_sparse_matrix.h [deleted file]
include/deal.II/lac/petsc_block_vector.h [deleted file]
include/deal.II/lac/petsc_matrix_free.h
include/deal.II/lac/petsc_parallel_block_vector.h
include/deal.II/lac/petsc_parallel_vector.h
include/deal.II/lac/petsc_sparse_matrix.h
include/deal.II/lac/petsc_vector.h [deleted file]
include/deal.II/numerics/error_estimator.templates.h
include/deal.II/numerics/matrix_creator.templates.h
include/deal.II/numerics/vector_tools.templates.h
source/algorithms/operator.cc
source/base/mpi.cc
source/base/time_stepping.cc
source/distributed/grid_refinement.cc
source/distributed/solution_transfer.cc
source/distributed/solution_transfer.inst.in
source/dofs/dof_accessor_get.cc
source/dofs/dof_accessor_set.cc
source/fe/fe_values.cc
source/fe/mapping_fe_field.cc
source/fe/mapping_q1_eulerian.cc
source/fe/mapping_q_eulerian.cc
source/grid/grid_refinement.cc
source/lac/CMakeLists.txt
source/lac/block_matrix_array.cc
source/lac/constraint_matrix.cc
source/lac/petsc_block_sparse_matrix.cc [deleted file]
source/lac/petsc_parallel_block_vector.cc
source/lac/petsc_parallel_sparse_matrix.cc
source/lac/petsc_parallel_vector.cc
source/lac/petsc_vector.cc [deleted file]
source/lac/petsc_vector_base.cc
source/lac/slepc_solver.cc
source/lac/slepc_spectral_transformation.cc
source/lac/solver.cc
source/lac/vector_memory.cc
source/meshworker/mesh_worker_info.cc
source/meshworker/mesh_worker_vector_selector.cc
source/multigrid/mg_base.cc
source/multigrid/mg_level_global_transfer.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/matrix_tools.cc
source/numerics/point_value_history.cc
source/numerics/solution_transfer.cc

index 312a0092595fbac3043ab02726cc4f1529444e02..7db400bd5de505ed8797172be788d3f9d6209626 100644 (file)
@@ -47,12 +47,10 @@ SERIAL_VECTORS := { Vector<double>;
                     @DEAL_II_EXPAND_TRILINOS_VECTOR@;
                     @DEAL_II_EXPAND_TRILINOS_MPI_VECTOR@;
                     @DEAL_II_EXPAND_EPETRA_VECTOR@;
-                    @DEAL_II_EXPAND_PETSC_VECTOR@;
                     @DEAL_II_EXPAND_PETSC_MPI_VECTOR@;
 
                     @DEAL_II_EXPAND_TRILINOS_BLOCKVECTOR@;
                     @DEAL_II_EXPAND_TRILINOS_MPI_BLOCKVECTOR@;
-                    @DEAL_II_EXPAND_PETSC_BLOCKVECTOR@;
                     @DEAL_II_EXPAND_PETSC_MPI_BLOCKVECTOR@;
                   }
 
@@ -75,12 +73,10 @@ REAL_SERIAL_VECTORS := { Vector<double>;
                     @DEAL_II_EXPAND_TRILINOS_VECTOR@;
                     @DEAL_II_EXPAND_TRILINOS_MPI_VECTOR@;
                     @DEAL_II_EXPAND_EPETRA_VECTOR@;
-                    @DEAL_II_EXPAND_PETSC_VECTOR_REAL@;
                     @DEAL_II_EXPAND_PETSC_MPI_VECTOR_REAL@;
 
                     @DEAL_II_EXPAND_TRILINOS_BLOCKVECTOR@;
                     @DEAL_II_EXPAND_TRILINOS_MPI_BLOCKVECTOR@;
-                    @DEAL_II_EXPAND_PETSC_BLOCKVECTOR_REAL@;
                     @DEAL_II_EXPAND_PETSC_MPI_BLOCKVECTOR_REAL@;
                   }
 
@@ -97,15 +93,12 @@ REAL_NONBLOCK_VECTORS := { Vector<double>;
                     @DEAL_II_EXPAND_TRILINOS_VECTOR@;
                     @DEAL_II_EXPAND_TRILINOS_MPI_VECTOR@;
                     @DEAL_II_EXPAND_EPETRA_VECTOR@;
-                    @DEAL_II_EXPAND_PETSC_VECTOR_REAL@;
                     @DEAL_II_EXPAND_PETSC_MPI_VECTOR_REAL@;
                   }
 
 // wrappers for non-MPI vectors (PETSc/Trilinos) 
 EXTERNAL_SEQUENTIAL_VECTORS := { @DEAL_II_EXPAND_TRILINOS_VECTOR@;
                                  @DEAL_II_EXPAND_TRILINOS_BLOCKVECTOR@;
-                                 @DEAL_II_EXPAND_PETSC_VECTOR@;
-                                 @DEAL_II_EXPAND_PETSC_BLOCKVECTOR@
                                }
 
 // wrappers for MPI vectors (PETSc/Trilinos) 
index f0635a2cf467c6130b5e17048ef40d8ecbb96d40..420435c6948a1e52257f1ba11de2ec9eaef54a18 100644 (file)
@@ -44,7 +44,7 @@
 #include <deal.II/numerics/data_out.h>
 #include <deal.II/lac/full_matrix.h>
 
-// IndexSet is used to set the size of PETScWrappers::Vector:
+// IndexSet is used to set the size of each PETScWrappers::MPI::Vector:
 #include <deal.II/base/index_set.h>
 
 // PETSc appears here because SLEPc depends on this library:
index cea9bffec08427d3ac51d75ef9e112296344cd67..d1011b9b4d69f93bbab927635df0a7f4c889b624 100644 (file)
@@ -30,7 +30,6 @@
 #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>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
index 9b5819b661776356b6d519b1897f25aa702d82d4..2eddceae25eac144ecc2ba89df04128060aa1b7b 100644 (file)
@@ -27,7 +27,6 @@
 #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>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
index 5f5f979fb70b2fa935c27c9800e7707606045f18..f809b665e214419151dcbef44492fecf9b244631 100644 (file)
@@ -32,7 +32,6 @@
 #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>
 
 #include <complex>
diff --git a/include/deal.II/lac/petsc_block_sparse_matrix.h b/include/deal.II/lac/petsc_block_sparse_matrix.h
deleted file mode 100644 (file)
index c57484c..0000000
+++ /dev/null
@@ -1,354 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2004 - 2016 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#ifndef dealii__petsc_block_sparse_matrix_h
-#define dealii__petsc_block_sparse_matrix_h
-
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_PETSC
-
-#  include <deal.II/base/table.h>
-#  include <deal.II/lac/block_matrix_base.h>
-#  include <deal.II/lac/petsc_sparse_matrix.h>
-#  include <deal.II/lac/petsc_block_vector.h>
-#  include <deal.II/lac/exceptions.h>
-
-#  include <cmath>
-
-DEAL_II_NAMESPACE_OPEN
-
-
-
-namespace PETScWrappers
-{
-
-  /*! @addtogroup PETScWrappers
-   *@{
-   */
-
-  /**
-   * Blocked sparse matrix based on the PETScWrappers::SparseMatrix class.
-   * This class implements the functions that are specific to the PETSc
-   * SparseMatrix base objects for a blocked sparse matrix, and leaves the
-   * actual work relaying most of the calls to the individual blocks to the
-   * functions implemented in the base class. See there also for a description
-   * of when this class is useful.
-   *
-   * In contrast to the deal.II-type SparseMatrix class, the PETSc matrices do
-   * not have external objects for the sparsity patterns. Thus, one does not
-   * determine the size of the individual blocks of a block matrix of this
-   * type by attaching a block sparsity pattern, but by calling reinit() to
-   * set the number of blocks and then by setting the size of each block
-   * separately. In order to fix the data structures of the block matrix, it
-   * is then necessary to let it know that we have changed the sizes of the
-   * underlying matrices. For this, one has to call the collect_sizes()
-   * function, for much the same reason as is documented with the
-   * BlockSparsityPattern class.
-   *
-   * @ingroup Matrix1 @see
-   * @ref GlossBlockLA "Block (linear algebra)"
-   * @author Wolfgang Bangerth, 2004
-   */
-  class BlockSparseMatrix : public BlockMatrixBase<PETScWrappers::SparseMatrix>
-  {
-  public:
-    /**
-     * Typedef the base class for simpler access to its own typedefs.
-     */
-    typedef BlockMatrixBase<SparseMatrix> BaseClass;
-
-    /**
-     * Typedef the type of the underlying matrix.
-     */
-    typedef BaseClass::BlockType  BlockType;
-
-    /**
-     * Import the typedefs from the base class.
-     */
-    typedef BaseClass::value_type      value_type;
-    typedef BaseClass::pointer         pointer;
-    typedef BaseClass::const_pointer   const_pointer;
-    typedef BaseClass::reference       reference;
-    typedef BaseClass::const_reference const_reference;
-    typedef BaseClass::size_type       size_type;
-    typedef BaseClass::iterator        iterator;
-    typedef BaseClass::const_iterator  const_iterator;
-
-    /**
-     * Constructor; initializes the matrix to be empty, without any structure,
-     * i.e.  the matrix is not usable at all. This constructor is therefore
-     * only useful for matrices which are members of a class. All other
-     * matrices should be created at a point in the data flow where all
-     * necessary information is available.
-     *
-     * You have to initialize the matrix before usage with
-     * reinit(BlockSparsityPattern). The number of blocks per row and column
-     * are then determined by that function.
-     */
-    BlockSparseMatrix ();
-
-    /**
-     * Destructor.
-     */
-    ~BlockSparseMatrix ();
-
-    /**
-     * Pseudo copy operator only copying empty objects. The sizes of the block
-     * matrices need to be the same.
-     */
-    BlockSparseMatrix &
-    operator = (const BlockSparseMatrix &);
-
-    /**
-     * This operator assigns a scalar to a matrix. Since this does usually not
-     * make much sense (should we set all matrix entries to this value? Only
-     * the nonzero entries of the sparsity pattern?), this operation is only
-     * allowed if the actual value to be assigned is zero. This operator only
-     * exists to allow for the obvious notation <tt>matrix=0</tt>, which sets
-     * all elements of the matrix to zero, but keep the sparsity pattern
-     * previously used.
-     */
-    BlockSparseMatrix &
-    operator = (const double d);
-
-    /**
-     * Resize the matrix, by setting the number of block rows and columns.
-     * This deletes all blocks and replaces them by uninitialized ones, i.e.
-     * ones for which also the sizes are not yet set. You have to do that by
-     * calling the @p reinit functions of the blocks themselves. Do not forget
-     * to call collect_sizes() after that on this object.
-     *
-     * The reason that you have to set sizes of the blocks yourself is that
-     * the sizes may be varying, the maximum number of elements per row may be
-     * varying, etc. It is simpler not to reproduce the interface of the @p
-     * SparsityPattern class here but rather let the user call whatever
-     * function she desires.
-     */
-    void reinit (const size_type n_block_rows,
-                 const size_type n_block_columns);
-
-    /**
-     * This function collects the sizes of the sub-objects and stores them in
-     * internal arrays, in order to be able to relay global indices into the
-     * matrix to indices into the subobjects. You *must* call this function
-     * each time after you have changed the size of the sub-objects.
-     */
-    void collect_sizes ();
-
-    /**
-     * Matrix-vector multiplication: let $dst = M*src$ with $M$ being this
-     * matrix.
-     */
-    void vmult (BlockVector       &dst,
-                const BlockVector &src) const;
-
-    /**
-     * Matrix-vector multiplication. Just like the previous function, but only
-     * applicable if the matrix has only one block column.
-     */
-    void vmult (BlockVector          &dst,
-                const Vector &src) const;
-
-    /**
-     * Matrix-vector multiplication. Just like the previous function, but only
-     * applicable if the matrix has only one block row.
-     */
-    void vmult (Vector    &dst,
-                const BlockVector &src) const;
-
-    /**
-     * Matrix-vector multiplication. Just like the previous function, but only
-     * applicable if the matrix has only one block.
-     */
-    void vmult (Vector       &dst,
-                const Vector &src) const;
-
-    /**
-     * Matrix-vector multiplication: let $dst = M^T*src$ with $M$ being this
-     * matrix. This function does the same as vmult() but takes the transposed
-     * matrix.
-     */
-    void Tvmult (BlockVector       &dst,
-                 const BlockVector &src) const;
-
-    /**
-     * Matrix-vector multiplication. Just like the previous function, but only
-     * applicable if the matrix has only one block row.
-     */
-    void Tvmult (BlockVector  &dst,
-                 const Vector &src) const;
-
-    /**
-     * Matrix-vector multiplication. Just like the previous function, but only
-     * applicable if the matrix has only one block column.
-     */
-    void Tvmult (Vector    &dst,
-                 const BlockVector &src) const;
-
-    /**
-     * Matrix-vector multiplication. Just like the previous function, but only
-     * applicable if the matrix has only one block.
-     */
-    void Tvmult (Vector       &dst,
-                 const Vector &src) const;
-
-    /**
-     * Return the partitioning of the domain space of this matrix, i.e., the
-     * partitioning of the vectors this matrix has to be multiplied with.
-     */
-    std::vector< size_type > locally_owned_domain_sizes() const;
-
-    /**
-     * Return the partitioning of the range space of this matrix, i.e., the
-     * partitioning of the vectors that are result from matrix-vector
-     * products.
-     */
-    std::vector< size_type > locally_owned_range_sizes() const;
-
-    /**
-     * Make the clear() function in the base class visible, though it is
-     * protected.
-     */
-    using BlockMatrixBase<SparseMatrix>::clear;
-
-    /**
-     * @addtogroup Exceptions
-     * @{
-     */
-
-    /**
-     * Exception
-     */
-    DeclException4 (ExcIncompatibleRowNumbers,
-                    int, int, int, int,
-                    << "The blocks [" << arg1 << ',' << arg2 << "] and ["
-                    << arg3 << ',' << arg4 << "] have differing row numbers.");
-    /**
-     * Exception
-     */
-    DeclException4 (ExcIncompatibleColNumbers,
-                    int, int, int, int,
-                    << "The blocks [" << arg1 << ',' << arg2 << "] and ["
-                    << arg3 << ',' << arg4 << "] have differing column numbers.");
-    ///@}
-  };
-
-
-
-  /*@}*/
-
-// ------------- inline and template functions -----------------
-
-  inline
-  BlockSparseMatrix &
-  BlockSparseMatrix::operator = (const double d)
-  {
-    Assert (d==0, ExcScalarAssignmentOnlyForZeroValue());
-
-    for (size_type r=0; r<this->n_block_rows(); ++r)
-      for (size_type c=0; c<this->n_block_cols(); ++c)
-        this->block(r,c) = d;
-
-    return *this;
-  }
-
-
-
-  inline
-  void
-  BlockSparseMatrix::vmult (BlockVector       &dst,
-                            const BlockVector &src) const
-  {
-    BaseClass::vmult_block_block (dst, src);
-  }
-
-
-
-  inline
-  void
-  BlockSparseMatrix::vmult (BlockVector  &dst,
-                            const Vector &src) const
-  {
-    BaseClass::vmult_block_nonblock (dst, src);
-  }
-
-
-
-  inline
-  void
-  BlockSparseMatrix::vmult (Vector            &dst,
-                            const BlockVector &src) const
-  {
-    BaseClass::vmult_nonblock_block (dst, src);
-  }
-
-
-
-  inline
-  void
-  BlockSparseMatrix::vmult (Vector       &dst,
-                            const Vector &src) const
-  {
-    BaseClass::vmult_nonblock_nonblock (dst, src);
-  }
-
-
-  inline
-  void
-  BlockSparseMatrix::Tvmult (BlockVector       &dst,
-                             const BlockVector &src) const
-  {
-    BaseClass::Tvmult_block_block (dst, src);
-  }
-
-
-
-  inline
-  void
-  BlockSparseMatrix::Tvmult (BlockVector  &dst,
-                             const Vector &src) const
-  {
-    BaseClass::Tvmult_block_nonblock (dst, src);
-  }
-
-
-
-  inline
-  void
-  BlockSparseMatrix::Tvmult (Vector            &dst,
-                             const BlockVector &src) const
-  {
-    BaseClass::Tvmult_nonblock_block (dst, src);
-  }
-
-
-
-  inline
-  void
-  BlockSparseMatrix::Tvmult (Vector       &dst,
-                             const Vector &src) const
-  {
-    BaseClass::Tvmult_nonblock_nonblock (dst, src);
-  }
-
-}
-
-DEAL_II_NAMESPACE_CLOSE
-
-#endif    // DEAL_II_WITH_PETSC
-
-#endif    // dealii__petsc_block_sparse_matrix_h
diff --git a/include/deal.II/lac/petsc_block_vector.h b/include/deal.II/lac/petsc_block_vector.h
deleted file mode 100644 (file)
index 5a9c182..0000000
+++ /dev/null
@@ -1,516 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2004 - 2017 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#ifndef dealii__petsc_block_vector_h
-#define dealii__petsc_block_vector_h
-
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_PETSC
-
-#  include <deal.II/lac/petsc_vector.h>
-#  include <deal.II/lac/petsc_parallel_block_vector.h>
-#  include <deal.II/lac/block_indices.h>
-#  include <deal.II/lac/block_vector_base.h>
-#  include <deal.II/lac/exceptions.h>
-#  include <deal.II/lac/vector_type_traits.h>
-
-DEAL_II_NAMESPACE_OPEN
-
-
-
-namespace PETScWrappers
-{
-  /*! @addtogroup PETScWrappers
-   *@{
-   */
-
-  /**
-   * An implementation of block vectors based on the vector class implemented
-   * in PETScWrappers. While the base class provides for most of the
-   * interface, this class handles the actual allocation of vectors and
-   * provides functions that are specific to the underlying vector type.
-   *
-   * This class is deprecated, use PETScWrappers::MPI::BlockVector.
-   *
-   * @ingroup Vectors
-   *
-   * @see
-   * @ref GlossBlockLA "Block (linear algebra)"
-   * @author Wolfgang Bangerth, 2004
-   */
-  class BlockVector : public BlockVectorBase<Vector>
-  {
-  public:
-    /**
-     * Typedef the base class for simpler access to its own typedefs.
-     */
-    typedef BlockVectorBase<Vector> BaseClass;
-
-    /**
-     * Typedef the type of the underlying vector.
-     */
-    typedef BaseClass::BlockType  BlockType;
-
-    /**
-     * Import the typedefs from the base class.
-     */
-    typedef BaseClass::value_type      value_type;
-    typedef BaseClass::pointer         pointer;
-    typedef BaseClass::const_pointer   const_pointer;
-    typedef BaseClass::reference       reference;
-    typedef BaseClass::const_reference const_reference;
-    typedef BaseClass::size_type       size_type;
-    typedef BaseClass::iterator        iterator;
-    typedef BaseClass::const_iterator  const_iterator;
-
-    /**
-     * Constructor. There are three ways to use this constructor. First,
-     * without any arguments, it generates an object with no blocks. Given one
-     * argument, it initializes <tt>num_blocks</tt> blocks, but these blocks
-     * have size zero. The third variant finally initializes all blocks to the
-     * same size <tt>block_size</tt>.
-     *
-     * Confer the other constructor further down if you intend to use blocks
-     * of different sizes.
-     */
-    explicit BlockVector (const unsigned int num_blocks = 0,
-                          const size_type    block_size = 0);
-
-    /**
-     * Copy-Constructor. Dimension set to that of V, all components are copied
-     * from V
-     */
-    BlockVector (const BlockVector  &V);
-
-    /**
-     * Copy-constructor: copy the values from a PETSc wrapper parallel block
-     * vector class.
-     *
-     *
-     * Note that due to the communication model of MPI, @em all processes have
-     * to actually perform this operation, even if they do not use the result.
-     * It is not sufficient if only one processor tries to copy the elements
-     * from the other processors over to its own process space.
-     */
-    explicit BlockVector (const MPI::BlockVector &v);
-
-    /**
-     * Constructor. Set the number of blocks to <tt>n.size()</tt> and
-     * initialize each block with <tt>n[i]</tt> zero elements.
-     */
-    BlockVector (const std::vector<size_type> &n);
-
-    /**
-     * Constructor. Set the number of blocks to <tt>n.size()</tt>. Initialize
-     * the vector with the elements pointed to by the range of iterators given
-     * as second and third argument. Apart from the first argument, this
-     * constructor is in complete analogy to the respective constructor of the
-     * <tt>std::vector</tt> class, but the first argument is needed in order
-     * to know how to subdivide the block vector into different blocks.
-     */
-    template <typename InputIterator>
-    BlockVector (const std::vector<size_type> &n,
-                 const InputIterator           first,
-                 const InputIterator           end);
-
-    /**
-     * Destructor. Clears memory
-     */
-    ~BlockVector ();
-
-    /**
-     * Copy operator: fill all components of the vector with the given scalar
-     * value.
-     */
-    BlockVector &operator = (const value_type s);
-
-    /**
-     * Copy operator for arguments of the same type.
-     */
-    BlockVector &
-    operator= (const BlockVector &V);
-
-    /**
-     * Copy all the elements of the parallel block vector @p v into this local
-     * vector. Note that due to the communication model of MPI, @em all
-     * processes have to actually perform this operation, even if they do not
-     * use the result. It is not sufficient if only one processor tries to
-     * copy the elements from the other processors over to its own process
-     * space.
-     */
-    BlockVector &
-    operator = (const MPI::BlockVector &v);
-
-    /**
-     * Reinitialize the BlockVector to contain <tt>num_blocks</tt> blocks of
-     * size <tt>block_size</tt> each.
-     *
-     * If <tt>omit_zeroing_entries==false</tt>, the vector is filled with
-     * zeros.
-     */
-    void reinit (const unsigned int num_blocks,
-                 const size_type    block_size,
-                 const bool omit_zeroing_entries = false);
-
-    /**
-     * Reinitialize the BlockVector such that it contains
-     * <tt>block_sizes.size()</tt> blocks. Each block is reinitialized to
-     * dimension <tt>block_sizes[i]</tt>.
-     *
-     * If the number of blocks is the same as before this function was called,
-     * all vectors remain the same and reinit() is called for each vector.
-     *
-     * If <tt>omit_zeroing_entries==false</tt>, the vector is filled with
-     * zeros.
-     *
-     * Note that you must call this (or the other reinit() functions)
-     * function, rather than calling the reinit() functions of an individual
-     * block, to allow the block vector to update its caches of vector sizes.
-     * If you call reinit() on one of the blocks, then subsequent actions on
-     * this object may yield unpredictable results since they may be routed to
-     * the wrong block.
-     */
-    void reinit (const std::vector<size_type> &N,
-                 const bool                   omit_zeroing_entries=false);
-
-    /**
-     * Change the dimension to that of the vector <tt>V</tt>. The same applies
-     * as for the other reinit() function.
-     *
-     * The elements of <tt>V</tt> are not copied, i.e.  this function is the
-     * same as calling <tt>reinit (V.size(), omit_zeroing_entries)</tt>.
-     *
-     * Note that you must call this (or the other reinit() functions)
-     * function, rather than calling the reinit() functions of an individual
-     * block, to allow the block vector to update its caches of vector sizes.
-     * If you call reinit() of one of the blocks, then subsequent actions of
-     * this object may yield unpredictable results since they may be routed to
-     * the wrong block.
-     */
-    void reinit (const BlockVector &V,
-                 const bool         omit_zeroing_entries=false);
-
-    /**
-     * Change the number of blocks to <tt>num_blocks</tt>. The individual
-     * blocks will get initialized with zero size, so it is assumed that the
-     * user resizes the individual blocks by herself in an appropriate way,
-     * and calls <tt>collect_sizes</tt> afterwards.
-     */
-    void reinit (const unsigned int num_blocks);
-
-    /**
-     * Swap the contents of this vector and the other vector <tt>v</tt>. One
-     * could do this operation with a temporary variable and copying over the
-     * data elements, but this function is significantly more efficient since
-     * it only swaps the pointers to the data of the two vectors and therefore
-     * does not need to allocate temporary storage and move data around.
-     *
-     * Limitation: right now this function only works if both vectors have the
-     * same number of blocks. If needed, the numbers of blocks should be
-     * exchanged, too.
-     *
-     * This function is analogous to the the swap() function of all C++
-     * standard containers. Also, there is a global function swap(u,v) that
-     * simply calls <tt>u.swap(v)</tt>, again in analogy to standard
-     * functions.
-     */
-    void swap (BlockVector &v);
-
-    /**
-     * Print to a stream.
-     */
-    void print (std::ostream       &out,
-                const unsigned int  precision = 3,
-                const bool          scientific = true,
-                const bool          across = true) const;
-
-    /**
-     * @addtogroup Exceptions
-     * @{
-     */
-
-    /**
-     * Exception
-     */
-    DeclException0 (ExcIteratorRangeDoesNotMatchVectorSize);
-    ///@}
-  } DEAL_II_DEPRECATED;
-
-  /*@}*/
-
-  /*----------------------- Inline functions ----------------------------------*/
-
-
-
-  inline
-  BlockVector::BlockVector (const unsigned int n_blocks,
-                            const size_type    block_size)
-  {
-    reinit (n_blocks, block_size);
-  }
-
-
-
-  inline
-  BlockVector::BlockVector (const std::vector<size_type> &n)
-  {
-    reinit (n, false);
-  }
-
-
-  inline
-  BlockVector::BlockVector (const BlockVector &v)
-    :
-    BlockVectorBase<Vector > ()
-  {
-    this->components.resize (v.n_blocks());
-    block_indices = v.block_indices;
-
-    for (unsigned int i=0; i<this->n_blocks(); ++i)
-      this->components[i] = v.components[i];
-  }
-
-
-
-  inline
-  BlockVector::BlockVector (const MPI::BlockVector &v)
-    :
-    BlockVectorBase<Vector > ()
-  {
-    this->components.resize (v.get_block_indices().size());
-    block_indices = v.get_block_indices();
-
-    for (unsigned int i=0; i<this->n_blocks(); ++i)
-      this->components[i] = v.block(i);
-  }
-
-
-
-  template <typename InputIterator>
-  BlockVector::BlockVector (const std::vector<size_type> &n,
-                            const InputIterator           first,
-                            const InputIterator           end)
-  {
-    // first set sizes of blocks, but
-    // don't initialize them as we will
-    // copy elements soon
-    (void)end;
-    reinit (n, true);
-    InputIterator start = first;
-    for (unsigned int b=0; b<n.size(); ++b)
-      {
-        InputIterator end = start;
-        std::advance (end, static_cast<signed int>(n[b]));
-
-        for (size_type i=0; i<n[b]; ++i, ++start)
-          this->block(b)(i) = *start;
-      }
-    Assert (start == end, ExcIteratorRangeDoesNotMatchVectorSize());
-  }
-
-
-
-  inline
-  BlockVector &
-  BlockVector::operator = (const value_type s)
-  {
-    BaseClass::operator = (s);
-    return *this;
-  }
-
-
-
-  inline
-  BlockVector &
-  BlockVector::operator = (const BlockVector &v)
-  {
-    BaseClass::operator = (v);
-    return *this;
-  }
-
-
-
-  inline
-  BlockVector &
-  BlockVector::operator = (const MPI::BlockVector &v)
-  {
-    BaseClass::operator = (v);
-    return *this;
-  }
-
-
-
-  inline
-  BlockVector::~BlockVector ()
-  {}
-
-
-  inline
-  void
-  BlockVector::reinit (const unsigned int n_bl,
-                       const size_type    bl_sz,
-                       const bool         omit_zeroing_entries)
-  {
-    std::vector<size_type> n(n_bl, bl_sz);
-    reinit(n, omit_zeroing_entries);
-  }
-
-
-
-  inline
-  void
-  BlockVector::reinit (const std::vector<size_type> &n,
-                       const bool                    omit_zeroing_entries)
-  {
-    block_indices.reinit (n);
-    if (this->components.size() != this->n_blocks())
-      this->components.resize(this->n_blocks());
-
-    for (unsigned int i=0; i<this->n_blocks(); ++i)
-      this->components[i].reinit(n[i], omit_zeroing_entries);
-  }
-
-
-  inline
-  void
-  BlockVector::reinit (const BlockVector &v,
-                       const bool omit_zeroing_entries)
-  {
-    block_indices = v.get_block_indices();
-    if (this->components.size() != this->n_blocks())
-      this->components.resize(this->n_blocks());
-
-    for (unsigned int i=0; i<this->n_blocks(); ++i)
-      block(i).reinit(v.block(i), omit_zeroing_entries);
-  }
-
-
-
-  inline
-  void
-  BlockVector::reinit (const unsigned int num_blocks)
-  {
-    reinit (num_blocks, 0, true);
-  }
-
-
-
-  inline
-  void
-  BlockVector::swap (BlockVector &v)
-  {
-    Assert (this->n_blocks() == v.n_blocks(),
-            ExcDimensionMismatch(this->n_blocks(), v.n_blocks()));
-
-    for (unsigned int i=0; i<this->n_blocks(); ++i)
-      this->components[i].swap (v.components[i]);
-    ::dealii::swap (this->block_indices, v.block_indices);
-  }
-
-
-
-  inline
-  void
-  BlockVector::print (std::ostream       &out,
-                      const unsigned int  precision,
-                      const bool          scientific,
-                      const bool          across) const
-  {
-    for (unsigned int i=0; i<this->n_blocks(); ++i)
-      {
-        if (across)
-          out << 'C' << i << ':';
-        else
-          out << "Component " << i << std::endl;
-        this->components[i].print(out, precision, scientific, across);
-      }
-  }
-
-
-
-
-  /**
-   * Global function which overloads the default implementation of the C++
-   * standard library which uses a temporary object. The function simply
-   * exchanges the data of the two vectors.
-   *
-   * @relates PETScWrappers::BlockVector
-   * @author Wolfgang Bangerth, 2000
-   */
-  inline
-  void swap (BlockVector &u,
-             BlockVector &v)
-  {
-    u.swap (v);
-  }
-
-}
-
-
-namespace internal
-{
-  namespace LinearOperator
-  {
-    template <typename> class ReinitHelper;
-
-    /**
-     * A helper class used internally in linear_operator.h. Specialization for
-     * PETScWrappers::BlockVector.
-     */
-    template<>
-    class ReinitHelper<PETScWrappers::BlockVector>
-    {
-    public:
-      template <typename Matrix>
-      static
-      void reinit_range_vector (const Matrix &matrix,
-                                PETScWrappers::BlockVector &v,
-                                bool omit_zeroing_entries)
-      {
-        v.reinit(matrix.locally_owned_range_sizes(), omit_zeroing_entries);
-      }
-
-      template <typename Matrix>
-      static
-      void reinit_domain_vector(const Matrix &matrix,
-                                PETScWrappers::BlockVector &v,
-                                bool omit_zeroing_entries)
-      {
-        v.reinit(matrix.locally_owned_domain_sizes(), omit_zeroing_entries);
-      }
-    };
-
-  } /* namespace LinearOperator */
-} /* namespace internal */
-
-
-/**
- * Declare dealii::PETScWrappers::BlockVector as serial vector.
- *
- * @author Uwe Koecher, 2017
- */
-template <>
-struct is_serial_vector< PETScWrappers::BlockVector > : std::true_type
-{
-};
-
-
-DEAL_II_NAMESPACE_CLOSE
-
-#endif  // DEAL_II_WITH_PETSC
-
-#endif
index fee301373f134776c6050ffa2813a66173fe655d..b256a533fc49415f4628df5bce99786d4690af63 100644 (file)
 #include <deal.II/base/config.h>
 
 #ifdef DEAL_II_WITH_PETSC
-
 #  include <deal.II/lac/exceptions.h>
 #  include <deal.II/lac/petsc_matrix_base.h>
-#  include <deal.II/lac/petsc_vector.h>
-
+#  include <deal.II/lac/petsc_parallel_vector.h>
 DEAL_II_NAMESPACE_OPEN
 
 
index 3a4a547c48e03177b112e566bbee34b28b76c1c1..8c5731900b4e1e7cdddff0ed9f92f886b6e03b89 100644 (file)
@@ -150,25 +150,6 @@ namespace PETScWrappers
       BlockVector &
       operator= (const BlockVector &V);
 
-      /**
-       * Copy the given sequential (non-distributed) block vector into the
-       * present parallel block vector. It is assumed that they have the same
-       * size, and this operation does not change the partitioning of the
-       * parallel vectors by which its elements are distributed across several
-       * MPI processes. What this operation therefore does is to copy that
-       * chunk of the given vector @p v that corresponds to elements of the
-       * target vector that are stored locally, and copies them, for each of
-       * the individual blocks of this object. Elements that are not stored
-       * locally are not touched.
-       *
-       * This being a parallel vector, you must make sure that @em all
-       * processes call this function at the same time. It is not possible to
-       * change the local part of a parallel vector on only one process,
-       * independent of what other processes do, with this function.
-       */
-      BlockVector &
-      operator= (const PETScWrappers::BlockVector &v);
-
       /**
        * Reinitialize the BlockVector to contain @p n_blocks of size @p
        * block_size, each of which stores @p local_size elements locally. The
index 2f07585ff34ad6c47cc1bcfb7f996287e6923f83..07fb0857e8c85de36eb487c7c62b165166f8b482 100644 (file)
@@ -36,9 +36,6 @@ DEAL_II_NAMESPACE_OPEN
  */
 namespace PETScWrappers
 {
-  // forward declaration for copy constructor from sequential vector
-  class Vector;
-
   /**
    * Namespace for PETSc classes that work in parallel over MPI, such as
    * distributed vectors and matrices.
@@ -263,23 +260,6 @@ namespace PETScWrappers
        */
       Vector &operator= (const Vector &v);
 
-      /**
-       * Copy the given sequential (non-distributed) vector into the present
-       * parallel vector. It is assumed that they have the same size, and this
-       * operation does not change the partitioning of the parallel vector by
-       * which its elements are distributed across several MPI processes. What
-       * this operation therefore does is to copy that chunk of the given
-       * vector @p v that corresponds to elements of the target vector that
-       * are stored locally, and copies them. Elements that are not stored
-       * locally are not touched.
-       *
-       * This being a parallel vector, you must make sure that @em all
-       * processes call this function at the same time. It is not possible to
-       * change the local part of a parallel vector on only one process,
-       * independent of what other processes do, with this function.
-       */
-      Vector &operator= (const PETScWrappers::Vector &v);
-
       /**
        * Set all components of the vector to the given number @p s. Simply
        * pass this down to the base class, but we still need to declare this
index ce88ecc7805670dbde81e521a0e92431176b85e6..ff1f27aed3dc965c1b615c5a34930bbfb3ce483e 100644 (file)
@@ -23,6 +23,7 @@
 
 #  include <deal.II/lac/exceptions.h>
 #  include <deal.II/lac/petsc_matrix_base.h>
+#  include <deal.II/lac/petsc_vector_base.h>
 #  include <vector>
 
 DEAL_II_NAMESPACE_OPEN
diff --git a/include/deal.II/lac/petsc_vector.h b/include/deal.II/lac/petsc_vector.h
deleted file mode 100644 (file)
index 28305a8..0000000
+++ /dev/null
@@ -1,440 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2004 - 2017 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#ifndef dealii__petsc_vector_h
-#define dealii__petsc_vector_h
-
-
-#include <deal.II/base/config.h>
-
-#ifdef DEAL_II_WITH_PETSC
-
-#  include <deal.II/base/subscriptor.h>
-#  include <deal.II/lac/exceptions.h>
-#  include <deal.II/lac/petsc_vector_base.h>
-#  include <deal.II/lac/petsc_parallel_vector.h>
-#  include <deal.II/lac/vector.h>
-#  include <deal.II/lac/vector_type_traits.h>
-
-DEAL_II_NAMESPACE_OPEN
-
-
-namespace PETScWrappers
-{
-  /*! @addtogroup PETScWrappers
-   *@{
-   */
-
-  /**
-   * Implementation of a sequential vector class based on PETSC. All the
-   * functionality is actually in the base class, except for the calls to
-   * generate a sequential vector. This is possible since PETSc only works on
-   * an abstract vector type and internally distributes to functions that do
-   * the actual work depending on the actual vector type (much like using
-   * virtual functions). Only the functions creating a vector of specific type
-   * differ, and are implemented in this particular class.
-   *
-   * This class is deprecated, use PETScWrappers::MPI::Vector instead.
-   *
-   * @ingroup Vectors
-   * @author Wolfgang Bangerth, 2004
-   */
-  class Vector : public VectorBase
-  {
-  public:
-    /**
-     * Declare type for container size.
-     */
-    typedef types::global_dof_index size_type;
-
-    /**
-     * Default constructor. Initialize the vector as empty.
-     */
-    Vector ();
-
-    /**
-     * Constructor. Set dimension to @p n and initialize all elements with
-     * zero.
-     *
-     * The constructor is made explicit to avoid accidents like this:
-     * <tt>v=0;</tt>. Presumably, the user wants to set every element of the
-     * vector to zero, but instead, what happens is this call:
-     * <tt>v=Vector@<number@>(0);</tt>, i.e. the vector is replaced by one of
-     * length zero.
-     */
-    explicit Vector (const size_type n);
-
-    /**
-     * Copy-constructor from deal.II vectors. Sets the dimension to that of
-     * the given vector, and copies all elements.
-     */
-    template <typename Number>
-    explicit Vector (const dealii::Vector<Number> &v);
-
-    /**
-     * Construct it from an existing PETSc Vector of type Vec. Note: this does
-     * not copy the contents and just keeps a pointer. You need to make sure
-     * the vector is not used twice at the same time or destroyed while in
-     * use. This class does not destroy the PETSc object. Handle with care!
-     */
-    explicit Vector (const Vec &v);
-
-    /**
-     * Copy-constructor the values from a PETSc wrapper vector class.
-     */
-    Vector (const Vector &v);
-
-    /**
-     * Copy-constructor: copy the values from a PETSc wrapper parallel vector
-     * class.
-     *
-     * Note that due to the communication model of MPI, @em all processes have
-     * to actually perform this operation, even if they do not use the result.
-     * It is not sufficient if only one processor tries to copy the elements
-     * from the other processors over to its own process space.
-     */
-    explicit Vector (const MPI::Vector &v);
-
-    /**
-     * Release all memory and return to a state just like after having called
-     * the default constructor.
-     */
-    void clear ();
-
-    /**
-     * Copy the given vector. Resize the present vector if necessary.
-     */
-    Vector &operator = (const Vector &v);
-
-    /**
-     * Copy all the elements of the parallel vector @p v into this local
-     * vector. Note that due to the communication model of MPI, @em all
-     * processes have to actually perform this operation, even if they do not
-     * use the result. It is not sufficient if only one processor tries to
-     * copy the elements from the other processors over to its own process
-     * space.
-     */
-    Vector &operator = (const MPI::Vector &v);
-
-    /**
-     * Set all components of the vector to the given number @p s. Simply pass
-     * this down to the base class, but we still need to declare this function
-     * to make the example given in the discussion about making the
-     * constructor explicit work.
-     *
-     * Since the semantics of assigning a scalar to a vector are not
-     * immediately clear, this operator should really only be used if you want
-     * to set the entire vector to zero. This allows the intuitive notation
-     * <tt>v=0</tt>. Assigning other values is deprecated and may be
-     * disallowed in the future.
-     */
-    Vector &operator = (const PetscScalar s);
-
-    /**
-     * Copy the values of a deal.II vector (as opposed to those of the PETSc
-     * vector wrapper class) into this object.
-     */
-    template <typename number>
-    Vector &operator = (const dealii::Vector<number> &v);
-
-    /**
-     * Change the dimension of the vector to @p N. It is unspecified how
-     * resizing the vector affects the memory allocation of this object; i.e.,
-     * it is not guaranteed that resizing it to a smaller size actually also
-     * reduces memory consumption, or if for efficiency the same amount of
-     * memory is used for less data.
-     *
-     * If @p omit_zeroing_entries is false, the vector is filled by zeros.
-     * Otherwise, the elements are left an unspecified state.
-     */
-    void reinit (const size_type N,
-                 const bool      omit_zeroing_entries = false);
-
-    /**
-     * Change the dimension to that of the vector @p v. The same applies as
-     * for the other reinit() function.
-     *
-     * The elements of @p v are not copied, i.e.  this function is the same as
-     * calling <tt>reinit (v.size(), omit_zeroing_entries)</tt>.
-     */
-    void reinit (const Vector &v,
-                 const bool    omit_zeroing_entries = false);
-
-  protected:
-    /**
-     * Create a vector of length @p n. For this class, we create a sequential
-     * vector. @p n denotes the total size of the vector to be created.
-     */
-    void create_vector (const size_type n);
-  } DEAL_II_DEPRECATED;
-
-  /*@}*/
-
-// ------------------ template and inline functions -------------
-
-
-  /**
-   * Global function @p swap which overloads the default implementation of the
-   * C++ standard library which uses a temporary object. The function simply
-   * exchanges the data of the two vectors.
-   *
-   * @relates PETScWrappers::Vector
-   * @author Wolfgang Bangerth, 2004
-   */
-  inline
-  void swap (Vector &u, Vector &v)
-  {
-    u.swap (v);
-  }
-
-
-#ifndef DOXYGEN
-
-  template <typename number>
-  Vector::Vector (const dealii::Vector<number> &v)
-  {
-    Vector::create_vector (v.size());
-
-    *this = v;
-  }
-
-
-
-  inline
-  Vector::Vector (const Vec &v)
-    :
-    VectorBase(v)
-  {}
-
-
-  inline
-  Vector &
-  Vector::operator = (const PetscScalar s)
-  {
-    VectorBase::operator = (s);
-
-    return *this;
-  }
-
-
-  inline
-  Vector &
-  Vector::operator = (const Vector &v)
-  {
-    // if the vectors have different sizes,
-    // then first resize the present one
-    if (size() != v.size())
-      reinit (v.size(), true);
-
-    const PetscErrorCode ierr = VecCopy (v.vector, vector);
-    AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-    return *this;
-  }
-
-
-
-  inline
-  Vector &
-  Vector::operator = (const MPI::Vector &v)
-  {
-    PetscErrorCode ierr;
-    if (attained_ownership)
-      {
-        // the petsc function we call wants to
-        // generate the vector itself, so destroy
-        // the old one first
-#if DEAL_II_PETSC_VERSION_LT(3,2,0)
-        ierr = VecDestroy (vector);
-#else
-        ierr = VecDestroy (&vector);
-#endif
-        AssertThrow (ierr == 0, ExcPETScError(ierr));
-      }
-
-    attained_ownership = true;
-
-    // then do the gather
-    // operation. <rant>petsc has changed its
-    // interface again, and replaced a single
-    // function call by several calls that
-    // are hard to understand. gets me all
-    // annoyed at their development
-    // model</rant>
-#if DEAL_II_PETSC_VERSION_LT(2,2,0)
-    ierr = VecConvertMPIToSeqAll (static_cast<const Vec &>(v),
-                                  &vector);
-    AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-#else
-
-    VecScatter ctx;
-
-    ierr = VecScatterCreateToAll (static_cast<const Vec &>(v), &ctx, &vector);
-    AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-#if ((PETSC_VERSION_MAJOR == 2) && \
-     ((PETSC_VERSION_MINOR < 3) || \
-      ((PETSC_VERSION_MINOR == 3) &&            \
-       (PETSC_VERSION_SUBMINOR < 3))))
-    ierr = VecScatterBegin (static_cast<const Vec &>(v), vector,
-                            INSERT_VALUES, SCATTER_FORWARD, ctx);
-    AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-    ierr = VecScatterEnd (static_cast<const Vec &>(v), vector,
-                          INSERT_VALUES, SCATTER_FORWARD, ctx);
-
-#else
-
-    ierr = VecScatterBegin (ctx,static_cast<const Vec &>(v), vector,
-                            INSERT_VALUES, SCATTER_FORWARD);
-    AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-    ierr = VecScatterEnd (ctx, static_cast<const Vec &>(v), vector,
-                          INSERT_VALUES, SCATTER_FORWARD);
-
-#endif
-    AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-#if DEAL_II_PETSC_VERSION_LT(3,2,0)
-    ierr = VecScatterDestroy (ctx);
-#else
-    ierr = VecScatterDestroy (&ctx);
-#endif
-    AssertThrow (ierr == 0, ExcPETScError(ierr));
-#endif
-
-    return *this;
-  }
-
-
-
-  template <typename number>
-  inline
-  Vector &
-  Vector::operator = (const dealii::Vector<number> &v)
-  {
-    reinit (v.size(), true);
-    // the following isn't necessarily fast,
-    // but this is due to the fact that PETSc
-    // doesn't offer an inlined access
-    // operator.
-    //
-    // if someone wants to contribute some
-    // code: to make this code faster, one
-    // could either first convert all values
-    // to PetscScalar, and then set them all
-    // at once using VecSetValues. This has
-    // the drawback that it could take quite
-    // some memory, if the vector is large,
-    // and it would in addition allocate
-    // memory on the heap, which is
-    // expensive. an alternative would be to
-    // split the vector into chunks of, say,
-    // 128 elements, convert a chunk at a
-    // time and set it in the output vector
-    // using VecSetValues. since 128 elements
-    // is small enough, this could easily be
-    // allocated on the stack (as a local
-    // variable) which would make the whole
-    // thing much more efficient.
-    //
-    // a second way to make things faster is
-    // for the special case that
-    // number==PetscScalar. we could then
-    // declare a specialization of this
-    // template, and omit the conversion. the
-    // problem with this is that the best we
-    // can do is to use VecSetValues, but
-    // this isn't very efficient either: it
-    // wants to see an array of indices,
-    // which in this case a) again takes up a
-    // whole lot of memory on the heap, and
-    // b) is totally dumb since its content
-    // would simply be the sequence
-    // 0,1,2,3,...,n. the best of all worlds
-    // would probably be a function in Petsc
-    // that would take a pointer to an array
-    // of PetscScalar values and simply copy
-    // n elements verbatim into the vector...
-    for (size_type i=0; i<v.size(); ++i)
-      (*this)(i) = v(i);
-
-    compress (::dealii::VectorOperation::insert);
-
-    return *this;
-  }
-#endif // DOXYGEN
-
-}
-
-namespace internal
-{
-  namespace LinearOperator
-  {
-    template <typename> class ReinitHelper;
-
-    /**
-     * A helper class used internally in linear_operator.h. Specialization for
-     * PETScWrappers::Vector.
-     */
-    template<>
-    class ReinitHelper<PETScWrappers::Vector>
-    {
-    public:
-      template <typename Matrix>
-      static
-      void reinit_range_vector (const Matrix &matrix,
-                                PETScWrappers::Vector &v,
-                                bool omit_zeroing_entries)
-      {
-        v.reinit( matrix.m(),
-                  omit_zeroing_entries);
-      }
-
-      template <typename Matrix>
-      static
-      void reinit_domain_vector(const Matrix &matrix,
-                                PETScWrappers::Vector &v,
-                                bool omit_zeroing_entries)
-      {
-        v.reinit( matrix.n(),
-                  omit_zeroing_entries);
-      }
-    };
-
-  } /* namespace LinearOperator */
-} /* namespace internal */
-
-
-/**
- * Declare dealii::PETScWrappers::Vector as serial vector.
- *
- * @author Uwe Koecher, 2017
- */
-template <>
-struct is_serial_vector< PETScWrappers::Vector > : std::true_type
-{
-};
-
-
-DEAL_II_NAMESPACE_CLOSE
-
-#endif // DEAL_II_WITH_PETSC
-
-/*----------------------------   petsc_vector.h     ---------------------------*/
-
-#endif
-/*----------------------------   petsc_vector.h     ---------------------------*/
index 780b9c2544f85fa07c2bf2758368666268a2061e..8c46da764b1bd78f8ba8d793ab23dab11859d459 100644 (file)
@@ -26,8 +26,8 @@
 #include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/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/petsc_parallel_vector.h>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/grid/tria_iterator.h>
index fb0ae2e85d4f61bfff0511d496b6c07ec92d9345..03655e4354fed62f76626450b43bdd5875a95ef4 100644 (file)
@@ -41,7 +41,7 @@
 #  include <deal.II/lac/petsc_parallel_sparse_matrix.h>
 #  include <deal.II/lac/petsc_sparse_matrix.h>
 #  include <deal.II/lac/petsc_parallel_vector.h>
-#  include <deal.II/lac/petsc_vector.h>
+#  include <deal.II/lac/petsc_parallel_vector.h>
 #  include <deal.II/lac/petsc_parallel_block_sparse_matrix.h>
 #endif
 
index 9da2b52a794da6e4794f931d5a947c7486c8ceea..7ee26717ae5eeac9fd888d9f0b4e5236feae0784 100644 (file)
@@ -28,9 +28,9 @@
 #include <deal.II/lac/la_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_epetra_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/sparse_matrix.h>
index 884778c336b0f21e6cc82fb18d6fc39e7b87b2a0..7f1487b271a2ee1a20efc1fa55ace3562c3396ce 100644 (file)
@@ -27,8 +27,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 
index b2bd554b18f68c92a1113a710fe2bbc8c0cde749..9e83208967a4fa26e832b27fca736c9a72b8090d 100644 (file)
 #endif
 
 #ifdef DEAL_II_WITH_PETSC
-#    include <petscsys.h>
-#    include <deal.II/lac/petsc_block_vector.h>
-#    include <deal.II/lac/petsc_parallel_block_vector.h>
-#    include <deal.II/lac/petsc_vector.h>
-#    include <deal.II/lac/petsc_parallel_vector.h>
+#  include <petscsys.h>
+#  include <deal.II/lac/petsc_parallel_block_vector.h>
+#  include <deal.II/lac/petsc_parallel_vector.h>
 #endif
 
 #ifdef DEAL_II_WITH_SLEPC
@@ -470,10 +468,6 @@ namespace Utilities
           ::release_unused_memory ();
           GrowingVectorMemory<PETScWrappers::MPI::BlockVector>
           ::release_unused_memory ();
-          GrowingVectorMemory<PETScWrappers::Vector>
-          ::release_unused_memory ();
-          GrowingVectorMemory<PETScWrappers::BlockVector>
-          ::release_unused_memory ();
 
 #  ifdef DEAL_II_WITH_SLEPC
           // and now end SLEPc (with PETSc)
index 372c4dce9493b5acd77851aa3f37889e76a1e29a..fa8c69ecb86da9eda92d0a44c21ee40137e44ca3 100644 (file)
@@ -18,8 +18,6 @@
 #include <deal.II/lac/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>
 #include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_epetra_vector.h>
index da791ed39a1feb2a07a59c0136761d2f85bef2c6..efd9a05fe4f6b74c6835a717be07072f7416c6c7 100644 (file)
@@ -17,8 +17,6 @@
 #include <deal.II/base/utilities.h>
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/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>
 #include <deal.II/lac/trilinos_block_vector.h>
 
index d5a1acbbaf61ad124609147fddbaf21e7b5f4353..27481365dbe65f5e6037672e8580a68fb96f5d58 100644 (file)
@@ -22,8 +22,8 @@
 #include <deal.II/lac/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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 
index 0363a7f6dabfc60eae7b6dda1270f963dc2ef23b..a5f6505c6d82c6199e8c5fe1a98df01cf807e9b1 100644 (file)
@@ -31,10 +31,6 @@ for (deal_II_dimension : DIMENSIONS; deal_II_space_dimension : SPACE_DIMENSIONS)
 
 
 #ifdef DEAL_II_WITH_PETSC
-    template class SolutionTransfer<deal_II_dimension, PETScWrappers::Vector, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
-
-    template class SolutionTransfer<deal_II_dimension, PETScWrappers::BlockVector, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
-
     template class SolutionTransfer<deal_II_dimension, PETScWrappers::MPI::Vector, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
 
     template class SolutionTransfer<deal_II_dimension, PETScWrappers::MPI::BlockVector, DoFHandler<deal_II_dimension,deal_II_space_dimension> >;
index 6015c62374e4235630f76fd1d85627c4efecb743..c4d8ca4ec3f0f601915153ae5685d2faba5522ca 100644 (file)
@@ -18,8 +18,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/sparse_matrix.h>
index 33e885e5c56674fa20bd331edf1ed14d65a14d1b..99bc5845628a55a9b3db6fa11b2f6e7ff8483a06 100644 (file)
@@ -18,8 +18,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/sparse_matrix.h>
index 8b0b59f345e6a1a806bf2af83d9fc52c6f1ea132..34f0eaee3cc1fda98ba0c0d5d86d8e8aa7655d26 100644 (file)
@@ -23,8 +23,8 @@
 #include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/la_parallel_block_vector.h>
 #include <deal.II/lac/vector_element_access.h>
-#include <deal.II/lac/petsc_vector.h>
-#include <deal.II/lac/petsc_block_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/grid/tria_iterator.h>
index cf56a5d51c0dc796877d4c6e47641bae3776786a..b612064a076efd2dfdb9d87d49efdf0d7a5e2cc5 100644 (file)
@@ -26,8 +26,8 @@
 #include <deal.II/lac/la_vector.h>
 #include <deal.II/lac/parallel_vector.h>
 #include <deal.II/lac/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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/trilinos_parallel_block_vector.h>
index 86493258149826e5fe6947c59efc1e1c91a21943..5534097355536b79d9c5fee4dbd078e263aac745 100644 (file)
@@ -19,8 +19,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/trilinos_parallel_block_vector.h>
index 5f650acf884260baed4f3a5eb845e92968d801ff..d46f57a6d95db1ceaa8b83ce64e64f68732062fd 100644 (file)
@@ -20,8 +20,8 @@
 #include <deal.II/lac/la_vector.h>
 #include <deal.II/lac/parallel_vector.h>
 #include <deal.II/lac/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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/trilinos_parallel_block_vector.h>
index 6b6b0933f520dc173223323ca71a82812f2aa455..870e3de68d08fbf554a83c26e2f534888e32c392 100644 (file)
@@ -18,8 +18,6 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector_base.h>
 #include <deal.II/lac/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>
 #include <deal.II/lac/trilinos_block_vector.h>
 
@@ -62,46 +60,6 @@ namespace
     // functions being unused:
     DEAL_II_DISABLE_EXTRA_DIAGNOSTICS
 
-#ifdef DEAL_II_WITH_PETSC
-    inline
-    PetscScalar
-    max_element (const PETScWrappers::Vector &criteria)
-    {
-      // this is horribly slow (since we have
-      // to get the array of values from PETSc
-      // in every iteration), but works
-      PetscScalar m = 0;
-#ifndef PETSC_USE_COMPLEX
-      for (unsigned int i=0; i<criteria.size(); ++i)
-        m = std::max (m, criteria(i));
-#else
-      Assert(false, ExcMessage("The GridRefinement functions should only get real-valued vectors of refinement indicators."
-                               " Using these functions with complex-valued PETSc vectors does not make sense."))
-#endif
-      return m;
-    }
-
-
-    inline
-    PetscScalar
-    min_element (const PETScWrappers::Vector &criteria)
-    {
-      // this is horribly slow (since we have
-      // to get the array of values from PETSc
-      // in every iteration), but works
-      PetscScalar m = criteria(0);
-#ifndef PETSC_USE_COMPLEX
-      for (unsigned int i=1; i<criteria.size(); ++i)
-        m = std::min (m, criteria(i));
-#else
-      Assert(false, ExcMessage("The GridRefinement functions should only get real-valued vectors of refinement indicators."
-                               " Using these functions with complex-valued PETSc vectors does not make sense."))
-#endif
-      return m;
-    }
-#endif
-
-
 #ifdef DEAL_II_WITH_TRILINOS
     inline
     TrilinosScalar
index 7f14f3ed6f91d76d4fe615ee05b1bc983a8a0c71..7bfd5c700b89fd89ba45faace059bff5264056cc 100644 (file)
@@ -84,7 +84,6 @@ SET(_inst
 IF(DEAL_II_WITH_PETSC)
   SET(_src
     ${_src}
-    petsc_block_sparse_matrix.cc
     petsc_full_matrix.cc
     petsc_matrix_base.cc
     petsc_matrix_free.cc
@@ -96,7 +95,6 @@ IF(DEAL_II_WITH_PETSC)
     petsc_solver.cc
     petsc_sparse_matrix.cc
     petsc_vector_base.cc
-    petsc_vector.cc
   )
 ENDIF()
 
index 476221eaad846fe6efc0d461fc7336507413ee5e..8191a18605247c7b61dffd0fd20732d341a6e41f 100644 (file)
@@ -20,7 +20,6 @@
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/trilinos_parallel_block_vector.h>
 
-#include <deal.II/lac/petsc_block_vector.h>
 #include <deal.II/lac/petsc_parallel_block_vector.h>
 
 DEAL_II_NAMESPACE_OPEN
index 2db76e807f5b8bced8ef166fb30f62e0439b896e..11c69edb1eb4659152950ebe6268bff7e68c443d 100644 (file)
 #include <deal.II/lac/la_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>
-#include <deal.II/lac/petsc_block_sparse_matrix.h>
 #include <deal.II/lac/petsc_parallel_vector.h>
 #include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/petsc_parallel_sparse_matrix.h>
@@ -1360,11 +1357,8 @@ MATRIX_FUNCTIONS(ChunkSparseMatrix<float>);
 
 #ifdef DEAL_II_WITH_PETSC
 MATRIX_FUNCTIONS(PETScWrappers::SparseMatrix);
-BLOCK_MATRIX_FUNCTIONS(PETScWrappers::BlockSparseMatrix);
 MATRIX_FUNCTIONS(PETScWrappers::MPI::SparseMatrix);
 BLOCK_MATRIX_FUNCTIONS(PETScWrappers::MPI::BlockSparseMatrix);
-MATRIX_VECTOR_FUNCTIONS(PETScWrappers::SparseMatrix, PETScWrappers::Vector);
-BLOCK_MATRIX_VECTOR_FUNCTIONS(PETScWrappers::BlockSparseMatrix, PETScWrappers::BlockVector);
 MATRIX_VECTOR_FUNCTIONS(PETScWrappers::MPI::SparseMatrix, PETScWrappers::MPI::Vector);
 BLOCK_MATRIX_VECTOR_FUNCTIONS(PETScWrappers::MPI::BlockSparseMatrix ,PETScWrappers::MPI::BlockVector);
 #endif
@@ -1440,7 +1434,6 @@ ONLY_MATRIX_FUNCTIONS(TrilinosWrappers::BlockSparseMatrix);
 
 #ifdef DEAL_II_WITH_PETSC
 ONLY_MATRIX_FUNCTIONS(PETScWrappers::SparseMatrix);
-ONLY_MATRIX_FUNCTIONS(PETScWrappers::BlockSparseMatrix);
 ONLY_MATRIX_FUNCTIONS(PETScWrappers::MPI::SparseMatrix);
 ONLY_MATRIX_FUNCTIONS(PETScWrappers::MPI::BlockSparseMatrix);
 #endif
diff --git a/source/lac/petsc_block_sparse_matrix.cc b/source/lac/petsc_block_sparse_matrix.cc
deleted file mode 100644 (file)
index 0681c7f..0000000
+++ /dev/null
@@ -1,104 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2004 - 2016 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#include <deal.II/lac/petsc_block_sparse_matrix.h>
-
-#ifdef DEAL_II_WITH_PETSC
-
-DEAL_II_NAMESPACE_OPEN
-
-namespace PETScWrappers
-{
-  BlockSparseMatrix::BlockSparseMatrix ()
-  {}
-
-
-
-  BlockSparseMatrix::~BlockSparseMatrix ()
-  {}
-
-
-
-  BlockSparseMatrix &
-  BlockSparseMatrix::operator = (const BlockSparseMatrix &m)
-  {
-    BaseClass::operator = (m);
-
-    return *this;
-  }
-
-
-  void
-  BlockSparseMatrix::
-  reinit (const size_type n_block_rows,
-          const size_type n_block_columns)
-  {
-    // first delete previous content of
-    // the subobjects array
-    clear ();
-
-    // then resize. set sizes of blocks to
-    // zero. user will later have to call
-    // collect_sizes for this
-    this->sub_objects.reinit (n_block_rows,
-                              n_block_columns);
-    this->row_block_indices.reinit (n_block_rows, 0);
-    this->column_block_indices.reinit (n_block_columns, 0);
-
-    // and reinitialize the blocks
-    for (size_type r=0; r<this->n_block_rows(); ++r)
-      for (size_type c=0; c<this->n_block_cols(); ++c)
-        {
-          BlockType *p = new BlockType();
-          this->sub_objects[r][c] = p;
-        }
-  }
-
-  std::vector<BlockSparseMatrix::size_type >
-  BlockSparseMatrix::
-  locally_owned_domain_sizes() const
-  {
-    std::vector< size_type > index_sets;
-
-    for ( unsigned int i=0; i<this->n_block_cols(); ++i)
-      index_sets.push_back(this->block(0,i).n());
-
-    return index_sets;
-  }
-
-  std::vector<BlockSparseMatrix::size_type >
-  BlockSparseMatrix::
-  locally_owned_range_sizes() const
-  {
-    std::vector< size_type > index_sets;
-
-    for ( unsigned int i=0; i<this->n_block_rows(); ++i)
-      index_sets.push_back(this->block(i,0).m());
-
-    return index_sets;
-  }
-
-  void
-  BlockSparseMatrix::collect_sizes ()
-  {
-    BaseClass::collect_sizes ();
-  }
-
-}
-
-
-DEAL_II_NAMESPACE_CLOSE
-
-#endif
index 5c66680de4f38950865e66a300c27bcb44a2358a..71f55dddf341326617b52de0aa0c09455f8933a5 100644 (file)
@@ -17,8 +17,6 @@
 
 #ifdef DEAL_II_WITH_PETSC
 
-#  include <deal.II/lac/petsc_block_vector.h>
-
 DEAL_II_NAMESPACE_OPEN
 
 namespace PETScWrappers
@@ -27,21 +25,6 @@ namespace PETScWrappers
   {
     typedef types::global_dof_index size_type;
 
-    BlockVector &
-    BlockVector::operator = (const PETScWrappers::BlockVector &v)
-    {
-      this->block_indices = v.get_block_indices();
-
-      if (this->components.size() != this->n_blocks())
-        this->components.resize(this->n_blocks());
-
-      for (unsigned int i=0; i<this->n_blocks(); ++i)
-        this->block(i) = v.block(i);
-
-      return *this;
-    }
-
-
     void
     BlockVector::reinit (const unsigned int num_blocks)
     {
index c2478f714668b6f8c12c9280af366022b178597b..1ae9dc3de7adafb6ce155e4deca640cd090262b6 100644 (file)
@@ -20,7 +20,7 @@
 #  include <deal.II/base/mpi.h>
 #  include <deal.II/lac/exceptions.h>
 #  include <deal.II/lac/petsc_compatibility.h>
-#  include <deal.II/lac/petsc_vector.h>
+#  include <deal.II/lac/petsc_parallel_vector.h>
 #  include <deal.II/lac/sparsity_pattern.h>
 #  include <deal.II/lac/dynamic_sparsity_pattern.h>
 
index a296d7ef9f9d48f5621fd09a960b0c57f9aa228a..ba2f8ee41d7c9f24ec1f075c183ffd7ab1da41aa 100644 (file)
@@ -18,7 +18,6 @@
 
 #ifdef DEAL_II_WITH_PETSC
 
-#  include <deal.II/lac/petsc_vector.h>
 #  include <cmath>
 #  include <algorithm>
 
@@ -250,52 +249,6 @@ namespace PETScWrappers
     }
 
 
-    Vector &
-    Vector::operator = (const PETScWrappers::Vector &v)
-    {
-      Assert(last_action==VectorOperation::unknown,
-             ExcMessage("Call to compress() required before calling operator=."));
-      //TODO [TH]: can not access v.last_action here. Implement is_compressed()?
-      //Assert(v.last_action==VectorOperation::unknown,
-      //    ExcMessage("Call to compress() required before calling operator=."));
-
-      // get a pointer to the local memory of
-      // this vector
-      PetscScalar *dest_array;
-      PetscErrorCode ierr = VecGetArray (vector, &dest_array);
-      AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-      // then also a pointer to the source
-      // vector
-      PetscScalar *src_array;
-      ierr = VecGetArray (static_cast<const Vec &>(v), &src_array);
-      AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-      // then copy:
-      const std::pair<size_type, size_type>
-      local_elements = local_range ();
-      std::copy (src_array + local_elements.first,
-                 src_array + local_elements.second,
-                 dest_array);
-
-      // finally restore the arrays
-      ierr = VecRestoreArray (vector, &dest_array);
-      AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-      ierr = VecRestoreArray (static_cast<const Vec &>(v), &src_array);
-      AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-      if (has_ghost_elements())
-        {
-          ierr = VecGhostUpdateBegin(vector, INSERT_VALUES, SCATTER_FORWARD);
-          AssertThrow (ierr == 0, ExcPETScError(ierr));
-          ierr = VecGhostUpdateEnd(vector, INSERT_VALUES, SCATTER_FORWARD);
-          AssertThrow (ierr == 0, ExcPETScError(ierr));
-        }
-      return *this;
-    }
-
-
     void
     Vector::create_vector (const size_type n,
                            const size_type local_size)
diff --git a/source/lac/petsc_vector.cc b/source/lac/petsc_vector.cc
deleted file mode 100644 (file)
index 3de9764..0000000
+++ /dev/null
@@ -1,133 +0,0 @@
-// ---------------------------------------------------------------------
-//
-// Copyright (C) 2004 - 2016 by the deal.II authors
-//
-// This file is part of the deal.II library.
-//
-// The deal.II library is free software; you can use it, redistribute
-// it, and/or modify it under the terms of the GNU Lesser General
-// Public License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
-// The full text of the license can be found in the file LICENSE at
-// the top level of the deal.II distribution.
-//
-// ---------------------------------------------------------------------
-
-#include <deal.II/lac/petsc_vector.h>
-
-#ifdef DEAL_II_WITH_PETSC
-
-#include <deal.II/lac/exceptions.h>
-
-#  include <cmath>
-
-DEAL_II_NAMESPACE_OPEN
-
-namespace PETScWrappers
-{
-
-
-  Vector::Vector ()
-  {
-    Vector::create_vector (0);
-  }
-
-
-
-  Vector::Vector (const size_type n)
-  {
-    Vector::create_vector (n);
-  }
-
-
-
-  Vector::Vector (const Vector &v)
-    :
-    VectorBase ()
-  {
-    // first create a dummy vector, then copy
-    // over the other one
-    Vector::create_vector (1);
-    Vector::operator = (v);
-  }
-
-
-
-  Vector::Vector (const MPI::Vector &v)
-  {
-    // first create a dummy vector, then copy
-    // over the other one
-    Vector::create_vector (1);
-    Vector::operator = (v);
-  }
-
-
-
-  void
-  Vector::clear ()
-  {
-    VectorBase::clear ();
-    Vector::create_vector (0);
-  }
-
-
-
-  void
-  Vector::reinit (const size_type n,
-                  const bool      omit_zeroing_entries)
-  {
-    // only do something if the sizes
-    // mismatch
-    if (size() != n)
-      {
-        // FIXME: I'd like to use this here,
-        // but somehow it leads to odd errors
-        // somewhere down the line in some of
-        // the tests:
-//         const PetscErrorCode ierr = VecSetSizes (vector, n, n);
-//         AssertThrow (ierr == 0, ExcPETScError(ierr));
-
-        // so let's go the slow way:
-        if (attained_ownership)
-          {
-#if DEAL_II_PETSC_VERSION_LT(3,2,0)
-            PetscErrorCode ierr = VecDestroy (vector);
-#else
-            PetscErrorCode ierr = VecDestroy (&vector);
-#endif
-            AssertThrow (ierr == 0, ExcPETScError(ierr));
-          }
-
-        create_vector (n);
-      }
-
-    // finally clear the new vector if so
-    // desired
-    if (omit_zeroing_entries == false)
-      *this = 0;
-  }
-
-
-
-  void
-  Vector::reinit (const Vector &v,
-                  const bool    omit_zeroing_entries)
-  {
-    reinit (v.size(), omit_zeroing_entries);
-  }
-
-
-
-  void
-  Vector::create_vector (const size_type n)
-  {
-    const PetscErrorCode ierr
-      = VecCreateSeq (PETSC_COMM_SELF, n, &vector);
-    AssertThrow (ierr == 0, ExcPETScError(ierr));
-    attained_ownership = true;
-  }
-}
-
-DEAL_II_NAMESPACE_CLOSE
-
-#endif // DEAL_II_WITH_PETSC
index ceddd323d8cb1b8a8cb0b343b3c808ec6bac07e4..2b63c29b1910b3278b69ea6a9c82e64b2ddf00ad 100644 (file)
@@ -20,7 +20,6 @@
 #  include <deal.II/base/memory_consumption.h>
 #  include <deal.II/lac/exceptions.h>
 #  include <deal.II/lac/petsc_compatibility.h>
-#  include <deal.II/lac/petsc_vector.h>
 #  include <deal.II/lac/petsc_parallel_vector.h>
 #  include <cmath>
 #  include <deal.II/base/multithread_info.h>
@@ -36,35 +35,12 @@ namespace PETScWrappers
       Assert (index < vector.size(),
               ExcIndexRange (index, 0, vector.size()));
 
-      // if the vector is local, then
-      // simply access the element we
-      // are interested in
-      if (dynamic_cast<const PETScWrappers::Vector *>(&vector) != nullptr)
-        {
-          PetscInt idx = index;
-          PetscScalar value;
-          PetscErrorCode ierr = VecGetValues(vector.vector, 1, &idx, &value);
-          AssertThrow (ierr == 0, ExcPETScError(ierr));
-          return value;
-        }
-
-      // there is the possibility
-      // that the vector has
-      // ghost elements. in that
-      // case, we first need to
-      // figure out which
-      // elements we own locally,
-      // then get a pointer to
-      // the elements that are
-      // stored here (both the
-      // ones we own as well as
-      // the ghost elements). in
-      // this array, the locally
-      // owned elements come
-      // first followed by the
-      // ghost elements whose
-      // position we can get from
-      // an index set
+      // The vector may have ghost entries. In that case, we first need to
+      // figure out which elements we own locally, then get a pointer to the
+      // elements that are stored here (both the ones we own as well as the
+      // ghost elements). In this array, the locally owned elements come first
+      // followed by the ghost elements whose position we can get from an
+      // index set.
       if (vector.ghosted)
         {
           PetscInt begin, end;
@@ -120,14 +96,10 @@ namespace PETScWrappers
       PetscErrorCode ierr = VecGetOwnershipRange (vector.vector, &begin, &end);
       AssertThrow (ierr == 0, ExcPETScError(ierr));
 
-
-
       AssertThrow ((index >= static_cast<size_type>(begin)) &&
                    (index < static_cast<size_type>(end)),
                    ExcAccessToNonlocalElement (index, begin, end-1));
 
-      // old version which only work with
-      // VecGetArray()...
       PetscInt idx = index;
       PetscScalar value;
       ierr = VecGetValues(vector.vector, 1, &idx, &value);
index e7f434c5f2ade4282cc15dc79798c6dd0cf26d8e..31d9ea86c2a8ffd6510782cafb148169b8c4681f 100644 (file)
@@ -19,7 +19,6 @@
 
 #  include <deal.II/lac/petsc_matrix_base.h>
 #  include <deal.II/lac/petsc_vector_base.h>
-#  include <deal.II/lac/petsc_vector.h>
 #  include <deal.II/lac/slepc_spectral_transformation.h>
 
 #  include <cmath>
index da0087a096616ba0cf2b2cbd681ce89d0d77fbff..bc7c59a12636c0095ca5d7070b26089c388033c7 100644 (file)
@@ -19,8 +19,6 @@
 
 #  include <deal.II/lac/slepc_solver.h>
 #  include <deal.II/lac/petsc_matrix_base.h>
-#  include <deal.II/lac/petsc_vector_base.h>
-#  include <deal.II/lac/petsc_vector.h>
 
 #  include <cmath>
 #  include <vector>
index b57404dfd1c36b866ea5d6a31bcb0cc29b49a665..141e317af1c13f6d89b3cca09c95a5b706f7922d 100644 (file)
@@ -19,8 +19,8 @@
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/block_vector.h>
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 
index dde669ca02f8d76f544f4ebaf2d7faad67473ab2..3cbd37ae29617809a4311accbd16bb339813499b 100644 (file)
@@ -18,8 +18,6 @@
 #include <deal.II/lac/la_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>
 #include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
index 288946d1558935acbeaaf51884cf57ccc673ff2c..d9982c46ca8a2cc490b6404c212ff902171f95ae 100644 (file)
@@ -16,8 +16,6 @@
 
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/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>
 #include <deal.II/lac/trilinos_block_vector.h>
 
@@ -31,4 +29,3 @@ DEAL_II_NAMESPACE_OPEN
 
 
 DEAL_II_NAMESPACE_CLOSE
-
index 271eceab65c1c1e607e4ae7fa0fdc54909aeb0b5..a40a97a77d6132b586af88cc3ccb4036dc70bf9e 100644 (file)
@@ -19,8 +19,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 
index 4a6b89add5dfa1c315d5c5f08f11b5f2a25caf79..640eef3b8c2fb4bf707b75a19529cb5a77af1f32 100644 (file)
@@ -18,8 +18,7 @@
 #include <deal.II/lac/la_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_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/multigrid/mg_base.h>
index 1ef738e1935fa48fddc1ac4cd6cff79fed19e3a7..65ccf6223a7154832c115c6b714d27dd6cd1c890 100644 (file)
@@ -21,8 +21,6 @@
 #include <deal.II/lac/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_epetra_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
index d2c188384730c5c7427ef1165264e6c0978bc5a7..8f2a04178ba0d96108fc64338a1c6df0c15dfb73 100644 (file)
@@ -21,8 +21,6 @@
 #include <deal.II/lac/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_epetra_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
index 19adb5148af267f522787e7f122840e2b1543684..32f49db7e8f910de37ff07908577adbc6fc2d1f0 100644 (file)
@@ -18,8 +18,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/sparse_matrix.h>
index 3b8ffea3647f1bbd335e4d6aa8c0c3688bf5e863..d3500b1278972fc6e54fb71fad8ca4d6ce0ef40a 100644 (file)
@@ -22,8 +22,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/vector_element_access.h>
index f760e06ab699664cf4b5e0923eae340da4ba0dbd..b612b576f4f421a6e68835ab9821c999dde00290 100644 (file)
@@ -20,8 +20,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/grid/tria_iterator.h>
index 02ee200098469ad9a5964ded379428d9e8617a3d..f8d61c6f83559c8a3b9fbd6d53164a87d8ce043d 100644 (file)
@@ -25,8 +25,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 
index 8ab52414bc1076920bfef2013e2186ae5e871e73..df6e3a2a411490a3399319ca2aa6cd2843ac5e7d 100644 (file)
@@ -22,8 +22,8 @@
 #include <deal.II/lac/la_parallel_vector.h>
 #include <deal.II/lac/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/petsc_parallel_vector.h>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/grid/tria_iterator.h>
index 229b389cfa0212655d937d6b502c20908d151f20..817af94c3870bb300ae82ec828ca32e076f806d5 100644 (file)
@@ -24,8 +24,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 
index c61582aa1b923b76d812b856e2db2292cf515f9a..7e11e2fe0dab8ba484c6584589eb86fc3c825004 100644 (file)
@@ -38,7 +38,6 @@
 #  include <deal.II/lac/petsc_parallel_sparse_matrix.h>
 #  include <deal.II/lac/petsc_sparse_matrix.h>
 #  include <deal.II/lac/petsc_parallel_vector.h>
-#  include <deal.II/lac/petsc_vector.h>
 #  include <deal.II/lac/petsc_parallel_block_sparse_matrix.h>
 #endif
 
index 43e12f367f629cf2ed7749a86f796190a9a5eab2..1a2148bab6d8c672b3a35726cf229c95f2bc4cb5 100644 (file)
@@ -19,8 +19,8 @@
 #include <deal.II/lac/la_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>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/trilinos_block_vector.h>
 #include <deal.II/lac/vector_element_access.h>
index fc31234f26c4d13b27f87995625f5ae5ad0e725c..41c4f00da22a8d3e2d7d64aef0ba94065d09d746 100644 (file)
 #include <deal.II/lac/vector.h>
 #include <deal.II/lac/la_vector.h>
 #include <deal.II/lac/la_parallel_vector.h>
-#include <deal.II/lac/petsc_vector.h>
+#include <deal.II/lac/petsc_parallel_vector.h>
+#include <deal.II/lac/petsc_parallel_block_vector.h>
 #include <deal.II/lac/trilinos_vector.h>
 #include <deal.II/lac/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>
 

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.