]> https://gitweb.dealii.org/ - dealii.git/commitdiff
Merge from mainline.
authorBruno Turcksin <bruno.turcksin@gmail.com>
Fri, 8 Mar 2013 18:11:21 +0000 (18:11 +0000)
committerBruno Turcksin <bruno.turcksin@gmail.com>
Fri, 8 Mar 2013 18:11:21 +0000 (18:11 +0000)
git-svn-id: https://svn.dealii.org/branches/branch_bigger_global_dof_indices_4@28824 0785d39b-7218-0410-832d-ea1e28bc413d

105 files changed:
1  2 
deal.II/examples/step-18/step-18.cc
deal.II/include/deal.II/base/index_set.h
deal.II/include/deal.II/base/utilities.h
deal.II/include/deal.II/base/work_stream.h
deal.II/include/deal.II/dofs/dof_renumbering.h
deal.II/include/deal.II/dofs/dof_tools.h
deal.II/include/deal.II/fe/fe_tools.h
deal.II/include/deal.II/fe/fe_values.h
deal.II/include/deal.II/grid/grid_generator.h
deal.II/include/deal.II/lac/arpack_solver.h
deal.II/include/deal.II/lac/block_indices.h
deal.II/include/deal.II/lac/block_matrix_base.h
deal.II/include/deal.II/lac/block_sparse_matrix.h
deal.II/include/deal.II/lac/block_sparsity_pattern.h
deal.II/include/deal.II/lac/block_vector.h
deal.II/include/deal.II/lac/block_vector.templates.h
deal.II/include/deal.II/lac/chunk_sparse_matrix.h
deal.II/include/deal.II/lac/chunk_sparse_matrix.templates.h
deal.II/include/deal.II/lac/constraint_matrix.h
deal.II/include/deal.II/lac/constraint_matrix.templates.h
deal.II/include/deal.II/lac/parallel_vector.h
deal.II/include/deal.II/lac/parallel_vector.templates.h
deal.II/include/deal.II/lac/petsc_block_sparse_matrix.h
deal.II/include/deal.II/lac/petsc_block_vector.h
deal.II/include/deal.II/lac/petsc_full_matrix.h
deal.II/include/deal.II/lac/petsc_matrix_base.h
deal.II/include/deal.II/lac/petsc_parallel_block_sparse_matrix.h
deal.II/include/deal.II/lac/petsc_parallel_block_vector.h
deal.II/include/deal.II/lac/petsc_parallel_sparse_matrix.h
deal.II/include/deal.II/lac/petsc_parallel_vector.h
deal.II/include/deal.II/lac/petsc_precondition.h
deal.II/include/deal.II/lac/petsc_sparse_matrix.h
deal.II/include/deal.II/lac/petsc_vector.h
deal.II/include/deal.II/lac/petsc_vector_base.h
deal.II/include/deal.II/lac/slepc_solver.h
deal.II/include/deal.II/lac/sparse_direct.h
deal.II/include/deal.II/lac/sparse_matrix.h
deal.II/include/deal.II/lac/sparse_matrix.templates.h
deal.II/include/deal.II/lac/sparse_vanka.templates.h
deal.II/include/deal.II/lac/sparsity_pattern.h
deal.II/include/deal.II/lac/sparsity_tools.h
deal.II/include/deal.II/lac/trilinos_block_sparse_matrix.h
deal.II/include/deal.II/lac/trilinos_block_vector.h
deal.II/include/deal.II/lac/trilinos_parallel_block_vector.h
deal.II/include/deal.II/lac/trilinos_precondition.h
deal.II/include/deal.II/lac/trilinos_sparse_matrix.h
deal.II/include/deal.II/lac/trilinos_sparsity_pattern.h
deal.II/include/deal.II/lac/trilinos_vector.h
deal.II/include/deal.II/lac/trilinos_vector_base.h
deal.II/include/deal.II/lac/vector.h
deal.II/include/deal.II/lac/vector.templates.h
deal.II/include/deal.II/matrix_free/fe_evaluation.h
deal.II/include/deal.II/matrix_free/matrix_free.h
deal.II/include/deal.II/matrix_free/matrix_free.templates.h
deal.II/include/deal.II/meshworker/dof_info.h
deal.II/include/deal.II/meshworker/simple.h
deal.II/include/deal.II/multigrid/mg_coarse.h
deal.II/include/deal.II/multigrid/mg_tools.h
deal.II/include/deal.II/multigrid/mg_transfer.h
deal.II/include/deal.II/multigrid/mg_transfer.templates.h
deal.II/include/deal.II/numerics/matrix_tools.h
deal.II/include/deal.II/numerics/vector_tools.h
deal.II/include/deal.II/numerics/vector_tools.templates.h
deal.II/source/base/index_set.cc
deal.II/source/base/utilities.cc
deal.II/source/distributed/tria.cc
deal.II/source/dofs/dof_handler_policy.cc
deal.II/source/dofs/dof_renumbering.cc
deal.II/source/dofs/dof_tools.cc
deal.II/source/fe/fe_tools.cc
deal.II/source/fe/fe_tools.inst.in
deal.II/source/grid/grid_generator.cc
deal.II/source/grid/grid_tools.cc
deal.II/source/grid/tria.cc
deal.II/source/lac/block_sparsity_pattern.cc
deal.II/source/lac/constraint_matrix.cc
deal.II/source/lac/constraint_matrix.inst.in
deal.II/source/lac/petsc_block_sparse_matrix.cc
deal.II/source/lac/petsc_full_matrix.cc
deal.II/source/lac/petsc_matrix_base.cc
deal.II/source/lac/petsc_parallel_block_sparse_matrix.cc
deal.II/source/lac/petsc_parallel_sparse_matrix.cc
deal.II/source/lac/petsc_parallel_vector.cc
deal.II/source/lac/petsc_sparse_matrix.cc
deal.II/source/lac/petsc_vector.cc
deal.II/source/lac/petsc_vector_base.cc
deal.II/source/lac/slepc_solver.cc
deal.II/source/lac/sparse_direct.cc
deal.II/source/lac/sparsity_tools.cc
deal.II/source/lac/tridiagonal_matrix.cc
deal.II/source/lac/trilinos_block_sparse_matrix.cc
deal.II/source/lac/trilinos_block_vector.cc
deal.II/source/lac/trilinos_precondition.cc
deal.II/source/lac/trilinos_sparse_matrix.cc
deal.II/source/lac/trilinos_sparsity_pattern.cc
deal.II/source/lac/trilinos_vector.cc
deal.II/source/lac/trilinos_vector_base.cc
deal.II/source/multigrid/mg_transfer_prebuilt.cc
deal.II/source/numerics/matrix_tools.cc
tests/distributed_grids/2d_dofhandler_01.cc
tests/mpi/p4est_2d_dofhandler_01.cc
tests/mpi/p4est_2d_dofhandler_03.cc
tests/mpi/p4est_2d_dofhandler_04.cc
tests/mpi/p4est_2d_renumber_01.cc
tests/mpi/p4est_2d_renumber_02.cc

Simple merge
index 364d83b55ffb4050e35ef7c311df5190e6e716f9,926eaa6e508399c4a2c4249cb0dd78a4f9a4da2e..7f5c0b11097fb18e7709bb435897f49865cd3cb9
@@@ -168,9 -168,9 +168,9 @@@ namespace FETool
     */
    template<int dim, int spacedim>
    void compute_block_renumbering (
-     const FiniteElement<dim,spacedim> &fe,
+     const FiniteElement<dim,spacedim>  &fe,
 -    std::vector<unsigned int> &renumbering,
 -    std::vector<unsigned int> &block_data,
 +    std::vector<types::global_dof_index> &renumbering,
 +    std::vector<types::global_dof_index> &block_data,
      bool return_start_indices = true);
  
    /**
index 054d3c673599793aadac911b427a321a792f1756,96ab4a635a130b24ac8293a1f82186227f37b590..702bb1e01faa4d1669d4ba573e32db12fbb71f0a
@@@ -635,8 -629,8 +634,8 @@@ public
     * @param R           The radius of the circle, which forms the middle line of the torus containing the loop of cells. Must be greater than @p r.
     * @param r           The radius of the cylinder bend together as loop.
     */
-   static void moebius (Triangulation<3,3> &tria,
+   static void moebius (Triangulation<3,3>  &tria,
 -                       const unsigned int   n_cells,
 +                       const size_type      n_cells,
                         const unsigned int   n_rotations,
                         const double         R,
                         const double         r);
index bb2567c2ea0850ff3d9218da84ca54624e5da86f,19c836bb6c35f10a46e6d6e4401709728611bdc2..5fca62c6a2c12279517688d6f871ca274166def0
@@@ -403,12 -398,13 +403,13 @@@ BlockIndices::push_back(const size_typ
  
  
  inline
 -std::pair<unsigned int,unsigned int>
 -BlockIndices::global_to_local (const unsigned int i) const
 +std::pair<unsigned int,BlockIndices::size_type>
 +BlockIndices::global_to_local (const size_type i) const
  {
    Assert (i<total_size(), ExcIndexRange(i, 0, total_size()));
+   Assert (n_blocks > 0, ExcLowerRange(i, 1));
  
-   int block = n_blocks-1;
+   unsigned int block = n_blocks-1;
    while (i < start_indices[block])
      --block;
  
index 49dd041fba3c3d4ff778f66a45fc6f8d79204544,1f796a01fce3ed59dbe84da9e342d47b9b61264c..18cfc16e5e35842fa9e10881e5edde3fc84e48a7
@@@ -1318,9 -1303,9 +1318,9 @@@ namespace BlockMatrixIterator
    template <class BlockMatrix>
    inline
    Accessor<BlockMatrix, true>::Accessor (
-     const BlockMatrix *matrix,
+     const BlockMatrix  *matrix,
 -    const unsigned int  row,
 -    const unsigned int  col)
 +    const size_type    row,
 +    const size_type    col)
      :
      matrix(matrix),
      base_iterator(matrix->block(0,0).begin())
    template <class BlockMatrix>
    inline
    Accessor<BlockMatrix, false>::Accessor (
-     BlockMatrix *matrix,
+     BlockMatrix  *matrix,
 -    const unsigned int  row,
 -    const unsigned int  col)
 +    const size_type row,
 +    const size_type col)
      :
      matrix(matrix),
      base_iterator(matrix->block(0,0).begin())
index aec4c1ebc72bfabe0ffe2cba0827dd2f179b81e3,40d824c3d564cdb46f61c03af23290590e7c1f89..c4df71fa0e250e91803e098ae4a9e2dcc3390642
@@@ -1771,8 -1766,8 +1771,8 @@@ private
     * row indices.
     */
    void
 -  make_sorted_row_list (const std::vector<unsigned int> &local_dof_indices,
 +  make_sorted_row_list (const std::vector<size_type> &local_dof_indices,
-                         internals::GlobalRowsFromLocal &global_rows) const;
+                         internals::GlobalRowsFromLocal  &global_rows) const;
  
    /**
     * Internal helper function for
index 35c6b4155ab1335e0f70a79f819e3202a337dcf2,76268dcdcbf260e495912365282f90774ea12718..0357c3df5b8a0fd4e9c230564c6884a355804a93
@@@ -2117,10 -2113,10 +2117,10 @@@ add_this_index
  // are related to it.
  void
  ConstraintMatrix::
 -make_sorted_row_list (const std::vector<unsigned int> &local_dof_indices,
 +make_sorted_row_list (const std::vector<size_type> &local_dof_indices,
-                       internals::GlobalRowsFromLocal &global_rows) const
+                       internals::GlobalRowsFromLocal  &global_rows) const
  {
 -  const unsigned int n_local_dofs = local_dof_indices.size();
 +  const size_type n_local_dofs = local_dof_indices.size();
    AssertDimension (n_local_dofs, global_rows.size());
  
    // when distributing the local data to
index df1c55c9030e6e160ffc19a09df0513739274873,088d0528e040e526cde2eb423cb1e9a8f712dbcc..4c2dde075a0c8afb8e85ca0c390882bdb14d62c1
@@@ -656,8 -656,8 +656,8 @@@ namespace paralle
         * indices.
         */
        template <typename OtherNumber>
 -      void add (const std::vector<unsigned int> &indices,
 +      void add (const std::vector<size_type>   &indices,
-                 const std::vector<OtherNumber> &values);
+                 const std::vector<OtherNumber>  &values);
  
        /**
         * This is a second collective
         * functions above.
         */
        template <typename OtherNumber>
 -      void add (const unsigned int  n_elements,
 -                const unsigned int *indices,
 +      void add (const size_type    n_elements,
 +                const size_type   *indices,
-                 const OtherNumber *values);
+                 const OtherNumber  *values);
  
        /**
         * Addition of @p s to all
      template <typename OtherNumber>
      inline
      void
 -    Vector<Number>::add (const std::vector<unsigned int> &indices,
 +    Vector<Number>::add (const std::vector<size_type> &indices,
-                          const std::vector<OtherNumber> &values)
+                          const std::vector<OtherNumber>  &values)
      {
        AssertDimension (indices.size(), values.size());
        add (indices.size(), &indices[0], &values[0]);
      template <typename OtherNumber>
      inline
      void
 -    Vector<Number>::add (const unsigned int  n_indices,
 -                         const unsigned int *indices,
 +    Vector<Number>::add (const size_type    n_indices,
 +                         const size_type   *indices,
-                          const OtherNumber *values)
+                          const OtherNumber  *values)
      {
 -      for (unsigned int i=0; i<n_indices; ++i)
 +      for (size_type i=0; i<n_indices; ++i)
          {
            Assert (numbers::is_finite(values[i]),
                    ExcMessage("The given value is not finite but either infinite or Not A Number (NaN)"));
index ec542b35bf6401e68529a890712791c49dcdc3f2,5622d55ba29470986be6df89893f55f28d39d2eb..30cfce14f3e61789be4459d19fd71424baecf005
@@@ -28,11 -28,11 +28,11 @@@ namespace paralle
      void
      Vector<Number>::clear_mpi_requests ()
      {
- #ifdef DEAL_II_COMPILER_SUPPORTS_MPI
+ #ifdef DEAL_II_WITH_MPI
 -      for (unsigned int j=0; j<compress_requests.size(); j++)
 +      for (size_type j=0; j<compress_requests.size(); j++)
          MPI_Request_free(&compress_requests[j]);
        compress_requests.clear();
 -      for (unsigned int j=0; j<update_ghost_values_requests.size(); j++)
 +      for (size_type j=0; j<update_ghost_values_requests.size(); j++)
          MPI_Request_free(&update_ghost_values_requests[j]);
        update_ghost_values_requests.clear();
  #endif
                << std::endl;
        out << std::endl << std::flush;
  
- #ifdef DEAL_II_COMPILER_SUPPORTS_MPI
+ #ifdef DEAL_II_WITH_MPI
        MPI_Barrier (partitioner->get_communicator());
  
 -      for (unsigned int i=partitioner->this_mpi_process()+1;
 +      for (size_type i=partitioner->this_mpi_process()+1;
             i<partitioner->n_mpi_processes(); i++)
          MPI_Barrier (partitioner->get_communicator());
  #endif
index f3c7f5200d711b2b88d178552c3f6e2326176d61,7715d722dd3880aaacbcb17502344fc15c35f5ef..f273b38939309c7cb5f0ad2cd261b29b84b23472
@@@ -445,10 -431,10 +445,10 @@@ namespace PETScWrapper
       * <tt>false</tt>, i.e., even zero
       * values are inserted/replaced.
       */
 -    void set (const unsigned int               row,
 -              const std::vector<unsigned int> &col_indices,
 +    void set (const size_type                 row,
 +              const std::vector<size_type >  &col_indices,
-               const std::vector<PetscScalar> &values,
+               const std::vector<PetscScalar>  &values,
 -              const bool                       elide_zero_values = false);
 +              const bool                      elide_zero_values = false);
  
      /**
       * Set several elements to values
       * <tt>false</tt>, i.e., even zero
       * values are inserted/replaced.
       */
 -    void set (const unsigned int  row,
 -              const unsigned int  n_cols,
 -              const unsigned int *col_indices,
 +    void set (const size_type    row,
 +              const size_type    n_cols,
 +              const size_type   *col_indices,
-               const PetscScalar *values,
+               const PetscScalar  *values,
 -              const bool          elide_zero_values = false);
 +              const bool         elide_zero_values = false);
  
      /**
       * Add @p value to the element
       * i.e., zero values won't be added
       * into the matrix.
       */
 -    void add (const unsigned int               row,
 -              const std::vector<unsigned int> &col_indices,
 +    void add (const size_type                 row,
 +              const std::vector<size_type>   &col_indices,
-               const std::vector<PetscScalar> &values,
+               const std::vector<PetscScalar>  &values,
 -              const bool                       elide_zero_values = true);
 +              const bool                      elide_zero_values = true);
  
      /**
       * Add an array of values given by
       * i.e., zero values won't be added
       * into the matrix.
       */
 -    void add (const unsigned int  row,
 -              const unsigned int  n_cols,
 -              const unsigned int *col_indices,
 +    void add (const size_type    row,
 +              const size_type    n_cols,
 +              const size_type   *col_indices,
-               const PetscScalar *values,
+               const PetscScalar  *values,
 -              const bool          elide_zero_values = true,
 -              const bool          col_indices_are_sorted = false);
 +              const bool         elide_zero_values = true,
 +              const bool         col_indices_are_sorted = false);
  
      /**
       * Remove all elements from
  
    inline
    void
 -  MatrixBase::set (const unsigned int               row,
 -                   const std::vector<unsigned int> &col_indices,
 +  MatrixBase::set (const size_type                 row,
 +                   const std::vector<size_type>   &col_indices,
-                    const std::vector<PetscScalar> &values,
+                    const std::vector<PetscScalar>  &values,
 -                   const bool                       elide_zero_values)
 +                   const bool                      elide_zero_values)
    {
      Assert (col_indices.size() == values.size(),
              ExcDimensionMismatch(col_indices.size(), values.size()));
  
    inline
    void
 -  MatrixBase::set (const unsigned int  row,
 -                   const unsigned int  n_cols,
 -                   const unsigned int *col_indices,
 +  MatrixBase::set (const size_type    row,
 +                   const size_type    n_cols,
 +                   const size_type   *col_indices,
-                    const PetscScalar *values,
+                    const PetscScalar  *values,
 -                   const bool          elide_zero_values)
 +                   const bool         elide_zero_values)
    {
      prepare_action(LastAction::insert);
  
  
    inline
    void
 -  MatrixBase::add (const unsigned int               row,
 -                   const std::vector<unsigned int> &col_indices,
 +  MatrixBase::add (const size_type                 row,
 +                   const std::vector<size_type>   &col_indices,
-                    const std::vector<PetscScalar> &values,
+                    const std::vector<PetscScalar>  &values,
 -                   const bool                       elide_zero_values)
 +                   const bool                      elide_zero_values)
    {
      Assert (col_indices.size() == values.size(),
              ExcDimensionMismatch(col_indices.size(), values.size()));
  
    inline
    void
 -  MatrixBase::add (const unsigned int  row,
 -                   const unsigned int  n_cols,
 -                   const unsigned int *col_indices,
 +  MatrixBase::add (const size_type    row,
 +                   const size_type    n_cols,
 +                   const size_type   *col_indices,
-                    const PetscScalar *values,
+                    const PetscScalar  *values,
 -                   const bool          elide_zero_values,
 +                   const bool         elide_zero_values,
                     const bool          /*col_indices_are_sorted*/)
    {
      prepare_action(LastAction::add);
index 2e00dc1c060b81af7070d4d38dcad601f1657b47,3d22318d1a2a11cd98bd997d6021bd31697970ea..c64fdd67178b66452cdbdd59365b7f5f4b4320e3
@@@ -89,12 -83,10 +89,12 @@@ namespace PETScWrapper
         * as to only allow the actual vector
         * class to create it.
         */
-       VectorReference (const VectorBase &vector,
+       VectorReference (const VectorBase  &vector,
 -                       const unsigned int index);
 +                       const size_type   index);
  
 -    public:
 +
 +      public:
 +      
        /**
         * This looks like a copy operator,
         * but does something different than
       * the corresponding values in the
       * second.
       */
 -    void set (const std::vector<unsigned int> &indices,
 +    void set (const std::vector<size_type>   &indices,
-               const std::vector<PetscScalar> &values);
+               const std::vector<PetscScalar>  &values);
  
      /**
       * A collective add operation: This
       * stored in @p values to the vector
       * components specified by @p indices.
       */
 -    void add (const std::vector<unsigned int> &indices,
 +    void add (const std::vector<size_type> &indices,
-               const std::vector<PetscScalar> &values);
+               const std::vector<PetscScalar>  &values);
  
      /**
       * This is a second collective
       * other two <tt>add()</tt>
       * functions above.
       */
 -    void add (const unsigned int  n_elements,
 -              const unsigned int *indices,
 +    void add (const size_type    n_elements,
 +              const size_type   *indices,
-               const PetscScalar *values);
+               const PetscScalar  *values);
  
      /**
       * Return the scalar product of two
       * @p add_values flag set to the
       * corresponding value.
       */
 -    void do_set_add_operation (const unsigned int  n_elements,
 -                               const unsigned int *indices,
 +    void do_set_add_operation (const size_type    n_elements,
 +                               const size_type   *indices,
-                                const PetscScalar *values,
+                                const PetscScalar  *values,
 -                               const bool add_values);
 +                               const bool         add_values);
  
  
    };
    namespace internal
    {
      inline
-     VectorReference::VectorReference (const VectorBase &vector,
+     VectorReference::VectorReference (const VectorBase  &vector,
 -                                      const unsigned int index)
 +                                      const size_type   index)
        :
        vector (vector),
        index (index)
index bd21d92236159c7fbf6b1b7d1d1fd782f38e92d1,5a5d9d673e3e4d93f6867c8f655b63bf28d03ee5..14adaac7ce3eeaa8cb9c62def0862eb640604715
@@@ -1310,16 -1300,16 +1310,16 @@@ class SparseDirectMUMP
  {
  private:
  
- #ifdef DEAL_II_USE_MUMPS
+ #ifdef DEAL_II_WITH_MUMPS
    DMUMPS_STRUC_C id;
- #endif // DEAL_II_USE_MUMPS
+ #endif // DEAL_II_WITH_MUMPS
  
 -  double       *a;
 -  double       *rhs;
 -  int          *irn;
 -  int          *jcn;
 -  unsigned int  n;
 -  unsigned int  nz;
 +  double   *a;
 +  double   *rhs;
 +  int      *irn;
 +  int      *jcn;
 +  types::global_dof_index n;
 +  types::global_dof_index nz;
  
    /**
     * This function initializes a MUMPS instance
index c049fdb8238f74fc17c0106d168685021682b4ee,8e75a8ad9f97277f106abc0c91cca034343fafd0..afc371164f3fab25ccc1b669dcf1f46e5f1f2db3
@@@ -387,17 -385,17 +387,17 @@@ namespace interna
      template <typename number,
               typename InVector,
               typename OutVector>
 -    void vmult_on_subrange (const unsigned int  begin_row,
 -                            const unsigned int  end_row,
 -                            const number       *values,
 +    void vmult_on_subrange (const size_type    begin_row,
 +                            const size_type    end_row,
 +                            const number      *values,
-                             const std::size_t *rowstart,
+                             const std::size_t  *rowstart,
 -                            const unsigned int *colnums,
 -                            const InVector     &src,
 -                            OutVector          &dst,
 -                            const bool          add)
 +                            const size_type   *colnums,
 +                            const InVector    &src,
 +                            OutVector         &dst,
 +                            const bool         add)
      {
 -      const number       *val_ptr    = &values[rowstart[begin_row]];
 -      const unsigned int *colnum_ptr = &colnums[rowstart[begin_row]];
 +      const number    *val_ptr    = &values[rowstart[begin_row]];
 +      const size_type *colnum_ptr = &colnums[rowstart[begin_row]];
        typename OutVector::iterator dst_ptr = dst.begin() + begin_row;
  
        if (add == false)
@@@ -772,12 -770,12 +772,12 @@@ namespace interna
       */
      template <typename number,
               typename InVector>
 -    number matrix_norm_sqr_on_subrange (const unsigned int  begin_row,
 -                                        const unsigned int  end_row,
 -                                        const number       *values,
 +    number matrix_norm_sqr_on_subrange (const size_type    begin_row,
 +                                        const size_type    end_row,
 +                                        const number      *values,
-                                         const std::size_t *rowstart,
+                                         const std::size_t  *rowstart,
 -                                        const unsigned int *colnums,
 -                                        const InVector     &v)
 +                                        const size_type   *colnums,
 +                                        const InVector    &v)
      {
        number norm_sqr=0.;
  
@@@ -835,13 -833,13 +835,13 @@@ namespace interna
       */
      template <typename number,
               typename InVector>
 -    number matrix_scalar_product_on_subrange (const unsigned int  begin_row,
 -                                              const unsigned int  end_row,
 -                                              const number       *values,
 +    number matrix_scalar_product_on_subrange (const size_type    begin_row,
 +                                              const size_type    end_row,
 +                                              const number      *values,
-                                               const std::size_t *rowstart,
+                                               const std::size_t  *rowstart,
 -                                              const unsigned int *colnums,
 -                                              const InVector     &u,
 -                                              const InVector     &v)
 +                                              const size_type   *colnums,
 +                                              const InVector    &u,
 +                                              const InVector    &v)
      {
        number norm_sqr=0.;
  
@@@ -1219,14 -1217,14 +1219,14 @@@ namespace interna
      template <typename number,
               typename InVector,
               typename OutVector>
 -    number residual_sqr_on_subrange (const unsigned int  begin_row,
 -                                     const unsigned int  end_row,
 -                                     const number       *values,
 +    number residual_sqr_on_subrange (const size_type    begin_row,
 +                                     const size_type    end_row,
 +                                     const number      *values,
-                                      const std::size_t *rowstart,
+                                      const std::size_t  *rowstart,
 -                                     const unsigned int *colnums,
 -                                     const InVector     &u,
 -                                     const InVector     &b,
 -                                     OutVector          &dst)
 +                                     const size_type   *colnums,
 +                                     const InVector    &u,
 +                                     const InVector    &b,
 +                                     OutVector         &dst)
      {
        number norm_sqr=0.;
  
@@@ -1287,10 -1285,10 +1287,10 @@@ SparseMatrix<number>::precondition_Jaco
    AssertDimension (dst.size(), n());
    AssertDimension (src.size(), n());
  
 -  const unsigned int n = src.size();
 -  somenumber              *dst_ptr = dst.begin();
 -  const somenumber        *src_ptr = src.begin();
 +  const size_type n = src.size();
 +  somenumber            *dst_ptr = dst.begin();
 +  const somenumber      *src_ptr = src.begin();
-   const std::size_t *rowstart_ptr = &cols->rowstart[0];
+   const std::size_t  *rowstart_ptr = &cols->rowstart[0];
  
    // optimize the following loop for
    // the case that the relaxation
index af510e256a9fd7f5a0fda79d56514cabd13d337c,6ae96146b4b532b372c93dd13fb172e8b6cf7495..d8586758bdf9cfd39a6ce16fb8f21dffc0b80ad8
@@@ -62,66 -62,65 +62,65 @@@ template <typename number
  void
  SparseVanka<number>::compute_inverses ()
  {
-   if (!DEAL_II_USE_MT)
-     compute_inverses (0, matrix->m());
-   else
-     {
-       const size_type n_inverses = std::count (selected.begin(),
-                                                selected.end(),
-                                                true);
+ #ifndef DEAL_II_WITH_THREADS
+   compute_inverses (0, matrix->m());
+ #else
 -  const unsigned int n_inverses = std::count (selected.begin(),
 -                                              selected.end(),
 -                                              true);
++  const size_type n_inverses = std::count (selected.begin(),
++                                           selected.end(),
++                                            true);
  
-       const size_type n_inverses_per_thread = std::max(n_inverses / n_threads, 
 -  const unsigned int n_inverses_per_thread = std::max(n_inverses / n_threads,
 -                                                      1U);
++  const size_type n_inverses_per_thread = std::max(n_inverses / n_threads, 
 +          static_cast<size_type> (1U));
  
-       // set up start and end index
-       // for each of the
-       // threads. note that we have
-       // to work somewhat to get this
-       // appropriate, since the
-       // indices for which inverses
-       // have to be computed may not
-       // be evenly distributed in the
-       // vector. as an extreme
-       // example consider numbering
-       // of DoFs by component, then
-       // all indices for which we
-       // have to do work will be
-       // consecutive, with other
-       // consecutive regions where we
-       // do not have to do something
-       std::vector<std::pair<size_type, size_type> > blocking (n_threads);
+   // set up start and end index
+   // for each of the
+   // threads. note that we have
+   // to work somewhat to get this
+   // appropriate, since the
+   // indices for which inverses
+   // have to be computed may not
+   // be evenly distributed in the
+   // vector. as an extreme
+   // example consider numbering
+   // of DoFs by component, then
+   // all indices for which we
+   // have to do work will be
+   // consecutive, with other
+   // consecutive regions where we
+   // do not have to do something
 -  std::vector<std::pair<unsigned int, unsigned int> > blocking (n_threads);
++  std::vector<std::pair<size_type, unsigned int> > blocking (n_threads);
  
-       unsigned int c       = 0;
-       unsigned int thread  = 0;
-       blocking[0].first = 0;
+   unsigned int c       = 0;
+   unsigned int thread  = 0;
+   blocking[0].first = 0;
  
-       for (size_type i=0; (i<matrix->m()) && (thread+1<n_threads); ++i)
 -  for (unsigned int i=0; (i<matrix->m()) && (thread+1<n_threads); ++i)
++  for (size_type i=0; (i<matrix->m()) && (thread+1<n_threads); ++i)
+     {
+       if (selected[i] == true)
+         ++c;
+       if (c == n_inverses_per_thread)
          {
-           if (selected[i] == true)
-             ++c;
-           if (c == n_inverses_per_thread)
-             {
-               blocking[thread].second  = i;
-               blocking[thread+1].first = i;
-               ++thread;
+           blocking[thread].second  = i;
+           blocking[thread+1].first = i;
+           ++thread;
  
-               c = 0;
-             };
+           c = 0;
          };
-       blocking[n_threads-1].second = matrix->m();
-       typedef void (SparseVanka<number>::*FunPtr)(const size_type,
-                                                   const size_type);
-       const FunPtr fun_ptr = &SparseVanka<number>::compute_inverses;
-       // Now spawn the threads
-       Threads::ThreadGroup<> threads;
-       for (unsigned int i=0; i<n_threads; ++i)
-         threads += Threads::new_thread (fun_ptr, *this,
-                                         blocking[i].first,
-                                         blocking[i].second);
-       threads.join_all ();
      };
 -  typedef void (SparseVanka<number>::*FunPtr)(const unsigned int,
 -                                              const unsigned int);
+   blocking[n_threads-1].second = matrix->m();
++  typedef void (SparseVanka<number>::*FunPtr)(const size_type,
++                                              const size_type);
+   const FunPtr fun_ptr = &SparseVanka<number>::compute_inverses;
+   // Now spawn the threads
+   Threads::ThreadGroup<> threads;
+   for (unsigned int i=0; i<n_threads; ++i)
+     threads += Threads::new_thread (fun_ptr, *this,
+                                     blocking[i].first,
+                                     blocking[i].second);
+   threads.join_all ();
+ #endif
  }
  
  
index 61cae06570cdb16e1574c1c0b9c5c77b23efb8e3,17c5599b267d04983262cc597d1f74a185650183..4e13a3f6fd5c631868d6af0e035a65a275704b3e
@@@ -537,9 -522,9 +537,9 @@@ public
     * matrix structure.  It must be compressed. The matrix structure is not
     * compressed after this function finishes.
     */
-   SparsityPattern (const SparsityPattern &original,
+   SparsityPattern (const SparsityPattern  &original,
 -                   const unsigned int      max_per_row,
 -                   const unsigned int      extra_off_diagonals);
 +                   const size_type        max_per_row,
 +                   const size_type        extra_off_diagonals);
  
    /**
     * Destructor.
index 5f572a16f5f60bfe42d932f2521265b908c10b8c,38567d370269b61f93b6e55929bd39e4965cf5fb..9f0777ddd595ad60cf0ddbfe69055989ae794086
@@@ -196,11 -191,11 +196,11 @@@ namespace SparsityTool
     */
    void
    reorder_Cuthill_McKee (const SparsityPattern     &sparsity,
 -                         std::vector<unsigned int> &new_indices,
 -                         const std::vector<unsigned int> &starting_indices = std::vector<unsigned int>());
 +                         std::vector<size_type> &new_indices,
 +                         const std::vector<size_type> &starting_indices = std::vector<size_type>());
  
  
- #ifdef DEAL_II_COMPILER_SUPPORTS_MPI
+ #ifdef DEAL_II_WITH_MPI
    /**
     * Communciate rows in a compressed
     * sparsity pattern over MPI.
index 6a13d093a265f6a3da5906844d3a6043573a18a4,172bc1077763ba9a741ef00ca38160063c7fffad..4b021208dc4f3e6180627e3fbf1cf8c079cf9711
@@@ -653,8 -648,8 +653,8 @@@ namespace TrilinosWrapper
       * argument, the corresponding
       * values in the second.
       */
 -    void set (const std::vector<unsigned int>    &indices,
 +    void set (const std::vector<size_type>    &indices,
-               const std::vector<TrilinosScalar> &values);
+               const std::vector<TrilinosScalar>  &values);
  
      /**
       * This is a second collective
  
    inline
    void
 -  VectorBase::set (const std::vector<unsigned int>    &indices,
 +  VectorBase::set (const std::vector<size_type>      &indices,
-                    const std::vector<TrilinosScalar> &values)
+                    const std::vector<TrilinosScalar>  &values)
    {
      // if we have ghost values, do not allow
      // writing to this vector at all.
  
    inline
    void
 -  VectorBase::add (const std::vector<unsigned int>    &indices,
 +  VectorBase::add (const std::vector<size_type>      &indices,
-                    const std::vector<TrilinosScalar> &values)
+                    const std::vector<TrilinosScalar>  &values)
    {
      // if we have ghost values, do not allow
      // writing to this vector at all.
index eb42a71694c66b1ae70c4cf6ed713f9fa7e87f34,05ebaa680d5b2066f6613413f4f40cdec2a1c5f2..24c83ea22d675cefea97ddaf48d8f8da97901ef9
@@@ -707,8 -707,8 +707,8 @@@ public
     * indices.
     */
    template <typename OtherNumber>
 -  void add (const std::vector<unsigned int> &indices,
 +  void add (const std::vector<size_type>   &indices,
-             const std::vector<OtherNumber> &values);
+             const std::vector<OtherNumber>  &values);
  
    /**
     * This is a second collective
     * functions above.
     */
    template <typename OtherNumber>
 -  void add (const unsigned int  n_elements,
 -            const unsigned int *indices,
 +  void add (const size_type    n_elements,
 +            const size_type   *indices,
-             const OtherNumber *values);
+             const OtherNumber  *values);
  
    /**
     * Addition of @p s to all
@@@ -1303,8 -1303,8 +1303,8 @@@ template <typename Number
  template <typename OtherNumber>
  inline
  void
 -Vector<Number>::add (const std::vector<unsigned int> &indices,
 +Vector<Number>::add (const std::vector<size_type> &indices,
-                      const std::vector<OtherNumber> &values)
+                      const std::vector<OtherNumber>  &values)
  {
    Assert (indices.size() == values.size(),
            ExcDimensionMismatch(indices.size(), values.size()));
@@@ -1331,11 -1331,11 +1331,11 @@@ template <typename Number
  template <typename OtherNumber>
  inline
  void
 -Vector<Number>::add (const unsigned int  n_indices,
 -                     const unsigned int *indices,
 +Vector<Number>::add (const size_type  n_indices,
 +                     const size_type *indices,
-                      const OtherNumber *values)
+                      const OtherNumber  *values)
  {
 -  for (unsigned int i=0; i<n_indices; ++i)
 +  for (size_type i=0; i<n_indices; ++i)
      {
        Assert (indices[i] < vec_size, ExcIndexRange(indices[i],0,vec_size));
        Assert (numbers::is_finite(values[i]),
index e1be3f30b218af8c6ab8acc08bc01a8fc85cb890,46116bd4e2aeb8d7102d6790716d47dd36ea49eb..08ea1d316b7e534aabb09f970f02579652445184
@@@ -97,14 -97,13 +97,13 @@@ namespace MeshWorke
       * The DoF indices of the
       * current cell
       */
 -    std::vector<unsigned int> indices;
 +    std::vector<types::global_dof_index> indices;
  
      /**
-      * The DoF indices on the
-      * current cell, organized by
-      * local blocks
+      * The DoF indices on the current cell, organized by local blocks.
+      * The size of this vector is zero, unless local blocks are used.
       */
 -    std::vector<std::vector<unsigned int> > indices_by_block;
 +    std::vector<std::vector<types::global_dof_index> > indices_by_block;
  
      /**
       * Constructor setting the
      template <class DHCellIterator, class DHFaceIterator>
      void reinit(const DHCellIterator &c,
                  const DHFaceIterator &f,
 -                const unsigned int n);
 +                const unsigned int face_no);
  
      /**
-      * Set the current subface
-      * and fill @p indices if the
-      * #cell changed.
+      * Set the current subface and fill @p indices if the #cell
+      * changed.
       */
      template <class DHCellIterator, class DHFaceIterator>
      void reinit(const DHCellIterator &c,
                  const DHFaceIterator &f,
 -                const unsigned int n,
 -                const unsigned int s);
 +                const unsigned int face_no,
 +                const unsigned int subface_no);
  
      /**
-      * Switch to a new face of the
-      * same cell. Does not change
-      * @p indices and does not reset
-      * data in LocalResults.
+      * Switch to a new face of the same cell. Does not change @p
+      * indices and does not reset data in LocalResults.
       */
      template <class DHFaceIterator>
      void set_face (const DHFaceIterator &f,
 -                   const unsigned int n);
 +                   const unsigned int face_no);
+     
      /**
-      * Switch to a new subface of the
-      * same cell. Does not change
-      * @p indices and does not reset
-      * data in LocalResults.
+      * Switch to a new subface of the same cell. Does not change @p
+      * indices and does not reset data in LocalResults.
       */
      template <class DHFaceIterator>
      void set_subface (const DHFaceIterator &f,
      template <class DHCellIterator>
      void get_indices(const DHCellIterator &c);
  
-     /// Fill index vector with level indices
-     //void get_indices(const typename MGDoFHandler<dim, spacedim>::cell_iterator& c);
      /// Auxiliary vector
 -    std::vector<unsigned int> indices_org;
 +    std::vector<types::global_dof_index> indices_org;
  
      /**
       * An auxiliary local
index 3418b0c61888e9b65708324c70506c77ca095e85,38be9336e27a9a4abd2f6b779c09ba9bf3637d22..e0afde78de39949fc6a74925bb2f4763c5d487e1
@@@ -805,8 -805,8 +805,8 @@@ namespace MatrixTool
     */
    template <typename number>
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          SparseMatrix<number> &matrix,
+                          SparseMatrix<number>  &matrix,
                           Vector<number>        &solution,
                           Vector<number>        &right_hand_side,
                           const bool             eliminate_columns = true);
     * step-18.
     */
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          PETScWrappers::SparseMatrix &matrix,
-                          PETScWrappers::Vector &solution,
-                          PETScWrappers::Vector &right_hand_side,
+                          PETScWrappers::SparseMatrix  &matrix,
+                          PETScWrappers::Vector  &solution,
+                          PETScWrappers::Vector  &right_hand_side,
                           const bool             eliminate_columns = true);
  
    /**
     * matrices.
     */
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          PETScWrappers::MPI::SparseMatrix &matrix,
-                          PETScWrappers::MPI::Vector &solution,
-                          PETScWrappers::MPI::Vector &right_hand_side,
+                          PETScWrappers::MPI::SparseMatrix  &matrix,
+                          PETScWrappers::MPI::Vector  &solution,
+                          PETScWrappers::MPI::Vector  &right_hand_side,
                           const bool             eliminate_columns = true);
  
    /**
     * to this function is the same.
     */
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          PETScWrappers::MPI::SparseMatrix &matrix,
+                          PETScWrappers::MPI::SparseMatrix  &matrix,
                           PETScWrappers::Vector       &solution,
-                          PETScWrappers::MPI::Vector &right_hand_side,
+                          PETScWrappers::MPI::Vector  &right_hand_side,
                           const bool             eliminate_columns = true);
  
    /**
     * across an MPI system.
     */
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          TrilinosWrappers::SparseMatrix &matrix,
+                          TrilinosWrappers::SparseMatrix  &matrix,
                           TrilinosWrappers::Vector        &solution,
                           TrilinosWrappers::Vector        &right_hand_side,
                           const bool             eliminate_columns = true);
     * working on block structures.
     */
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          TrilinosWrappers::BlockSparseMatrix &matrix,
+                          TrilinosWrappers::BlockSparseMatrix  &matrix,
                           TrilinosWrappers::BlockVector        &solution,
                           TrilinosWrappers::BlockVector        &right_hand_side,
                           const bool                eliminate_columns = true);
     * types.
     */
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          TrilinosWrappers::SparseMatrix &matrix,
+                          TrilinosWrappers::SparseMatrix  &matrix,
                           TrilinosWrappers::MPI::Vector   &solution,
                           TrilinosWrappers::MPI::Vector   &right_hand_side,
                           const bool             eliminate_columns = true);
     * on block structures.
     */
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          TrilinosWrappers::BlockSparseMatrix &matrix,
+                          TrilinosWrappers::BlockSparseMatrix  &matrix,
                           TrilinosWrappers::MPI::BlockVector   &solution,
                           TrilinosWrappers::MPI::BlockVector   &right_hand_side,
                           const bool                eliminate_columns = true);
Simple merge
Simple merge
Simple merge
index 618c6cbdfdf8e0a27c98b7dbf9c0c091bbf5517e,8295743bfa0ccdfe770b6b78eef9fc2b9d16b659..92aedf95fe29e2108cb8ca591783029b688b1b1d
@@@ -719,8 -718,8 +719,8 @@@ namespace DoFRenumberin
          = (dynamic_cast<const parallel::distributed::Triangulation<dim,spacedim>*>
             (&start->get_dof_handler().get_tria())))
        {
- #ifdef DEAL_II_USE_P4EST
+ #ifdef DEAL_II_WITH_P4EST
 -        std::vector<unsigned int> local_dof_count(n_buckets);
 +        std::vector<types::global_dof_index> local_dof_count(n_buckets);
  
          for (unsigned int c=0; c<n_buckets; ++c)
            local_dof_count[c] = component_to_dof_map[c].size();
          = (dynamic_cast<const parallel::distributed::Triangulation<dim,spacedim>*>
             (&start->get_dof_handler().get_tria())))
        {
- #ifdef DEAL_II_USE_P4EST
+ #ifdef DEAL_II_WITH_P4EST
 -        std::vector<unsigned int> local_dof_count(n_buckets);
 +        std::vector<types::global_dof_index> local_dof_count(n_buckets);
  
          for (unsigned int c=0; c<n_buckets; ++c)
            local_dof_count[c] = block_to_dof_map[c].size();
index c05918b0057efdda35a6a67b3c58c010e0c687b9,45a2e0406f9cb2ee51a3d28835af00fd222c59dc..47c44d2b9ced449ff2e30a10cb07d935712516b5
@@@ -4520,8 -4520,8 +4520,8 @@@ namespace DoFTool
    template <class DH>
    void
    count_dofs_per_block (const DH &dof_handler,
 -                        std::vector<unsigned int> &dofs_per_block,
 +                        std::vector<types::global_dof_index> &dofs_per_block,
-                         const std::vector<unsigned int> &target_block_)
+                         const std::vector<unsigned int>  &target_block_)
    {
      std::vector<unsigned int>  target_block = target_block_;
  
        template <class DH>
        void
        map_dofs_to_support_points(const hp::MappingCollection<DH::dimension, DH::space_dimension> &mapping,
-                                  const DH &dof_handler,
-                                  std::vector<Point<DH::space_dimension> > &support_points)
+                                  const DH  &dof_handler,
+                                  std::vector<Point<DH::space_dimension> >  &support_points)
        {
          // get the data in the form of the map as above
 -        std::map<unsigned int,Point<DH::space_dimension> >  x_support_points;
 +        std::map<types::global_dof_index,Point<DH::space_dimension> >  x_support_points;
          map_dofs_to_support_points(mapping, dof_handler, x_support_points);
  
          // now convert from the map to the linear vector. make sure every
Simple merge
Simple merge
index da5e36333fcf2c6cf671fcd343feba3f89f6a16b,9f80cc3422c31bcf82aae6c5af51ffa40e2cdfc2..809b3304977e245c01b2907180812b6da1dbda87
@@@ -181,8 -181,8 +181,8 @@@ void GridGenerator::hyper_cube (Triangu
  
  void
  GridGenerator::moebius (
-   Triangulation<3> &tria,
+   Triangulation<3>  &tria,
 -  const unsigned int   n_cells,
 +  const size_type      n_cells,
    const unsigned int   n_rotations,
    const double         R,
    const double         r)
Simple merge
Simple merge
index 0000000000000000000000000000000000000000,400f44cd4f28da04e519f9937dfa24eb273ab2e5..72131b5396489e3c3c9012c183dec8753edece98
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,59 +1,59 @@@
 -      const Vector<double>&, const std::vector<unsigned int> &, T<S> &, const FullMatrix<double>&) const;
+ 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<double>&, const std::vector<unsigned int> &, parallel::distributed::T<S> &, const FullMatrix<double>&) const;
++      const Vector<double>&, const std::vector<types::global_dof_index> &, T<S> &, const FullMatrix<double>&) const;
+     template void ConstraintMatrix::distribute<T<S> >(const T<S> &, T<S> &) const;
+     template void ConstraintMatrix::distribute<T<S> >(T<S> &) const;
+     template void ConstraintMatrix::set_zero<T<S> >(T<S> &) const;
+   }
+ 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<double>&, const std::vector<unsigned int> &, V&, const FullMatrix<double>&) const;
++      const Vector<double>&, const std::vector<types::global_dof_index> &, parallel::distributed::T<S> &, const FullMatrix<double>&) const;
+     template void ConstraintMatrix::distribute<parallel::distributed::T<S> >(const parallel::distributed::T<S> &, parallel::distributed::T<S> &) const;
+     template void ConstraintMatrix::distribute<parallel::distributed::T<S> >(parallel::distributed::T<S> &) const;
+     template void ConstraintMatrix::set_zero<parallel::distributed::T<S> >(parallel::distributed::T<S> &) const;
+   }
+ for (V: EXTERNAL_SEQUENTIAL_VECTORS)
+   {
+     template void ConstraintMatrix::condense<V >(const V&, V&) const;
+     template void ConstraintMatrix::condense<V >(V&vec) const;
+     template void ConstraintMatrix::distribute_local_to_global<V > (
++      const Vector<double>&, const std::vector<types::global_dof_index> &, V&, const FullMatrix<double>&) const;
+     template void ConstraintMatrix::distribute<V >(const V&, V&) const;
+     template void ConstraintMatrix::distribute<V >(V&) const;
+     template void ConstraintMatrix::set_zero<V >(V&) const;
+   }
+ for (V: EXTERNAL_PARALLEL_VECTORS)
+   {
+     template void ConstraintMatrix::set_zero<V >(V&) const;
+   }
+ for (S : REAL_SCALARS)
+   {
+     template void ConstraintMatrix::condense<S>(const SparseMatrix<S>&, SparseMatrix<S> &) const;
+     template void ConstraintMatrix::condense<S>(SparseMatrix<S>&) const;
+     template void ConstraintMatrix::condense<S>(BlockSparseMatrix<S>&) const;
+   }
+ 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;
+     template void ConstraintMatrix::condense<S1,Vector<S2> >(
+         const SparseMatrix<S1>&, const Vector<S2>&, SparseMatrix<S1> &, Vector<S2>&) const;
+     template void ConstraintMatrix::condense<S1,BlockVector<S2> >(
+         const SparseMatrix<S1>&, const BlockVector<S2>&, SparseMatrix<S1> &, BlockVector<S2>&) const;
+   }
index 5f8bc77c80aba141b3d02ab87440028c059f12af,cf3bd0c4e72aaca4bfde7b15fdf1ff2dd11a8191..cdb723e811480adde251a074d4c3c6020767978f
@@@ -52,9 -52,9 +52,9 @@@ namespace PETScWrapper
  
  
  
 -    Vector::Vector (const MPI_Comm    &communicator,
 +    Vector::Vector (const MPI_Comm   &communicator,
-                     const VectorBase &v,
+                     const VectorBase  &v,
 -                    const unsigned int local_size)
 +                    const size_type   local_size)
        :
        communicator (communicator)
      {
Simple merge
index e0de106e1be2e190154a3bbfd2c3caa9d31fcd64,439a6bfcaba59a75006e34209508019b0c556dc6..5cd88bb7ea4d7e59085242b4ceaaca9c685ddaf3
@@@ -316,8 -316,8 +316,8 @@@ namespace PETScWrapper
  
  
    void
 -  VectorBase::set (const std::vector<unsigned int> &indices,
 +  VectorBase::set (const std::vector<size_type> &indices,
-                    const std::vector<PetscScalar> &values)
+                    const std::vector<PetscScalar>  &values)
    {
      Assert (indices.size() == values.size(),
              ExcMessage ("Function called with arguments of different sizes"));
  
  
    void
 -  VectorBase::add (const std::vector<unsigned int> &indices,
 +  VectorBase::add (const std::vector<size_type> &indices,
-                    const std::vector<PetscScalar> &values)
+                    const std::vector<PetscScalar>  &values)
    {
      Assert (indices.size() == values.size(),
              ExcMessage ("Function called with arguments of different sizes"));
Simple merge
Simple merge
index bb82de0bde19a2b76528b29d9360f21336379a1f,218f348d8ed0a70d81dc84a60cbaa76e3ff33c8f..d4bb86da9c54ce60b4ddcc98f1674447f51e2c46
@@@ -374,10 -374,10 +374,10 @@@ namespace SparsityTool
              ExcInternalError());
    }
  
- #ifdef DEAL_II_COMPILER_SUPPORTS_MPI
+ #ifdef DEAL_II_WITH_MPI
    template <class CSP_t>
    void distribute_sparsity_pattern(CSP_t &csp,
 -                                   const std::vector<unsigned int> &rows_per_cpu,
 +                                   const std::vector<size_type> &rows_per_cpu,
                                     const MPI_Comm &mpi_comm,
                                     const IndexSet &myrange)
    {
index 41631c5486e63602af6c15f202d9e577f87dbb1d,f01ada3dcca7b9bab3e106eaf627e5bbec800d58..25e6f8665fdbbb94e7b050f31898e2415c7e5a69
@@@ -111,8 -111,8 +111,8 @@@ namespace TrilinosWrapper
  
  
  
-   SparseMatrix::SparseMatrix (const Epetra_Map &input_map,
+   SparseMatrix::SparseMatrix (const Epetra_Map  &input_map,
 -                              const unsigned int n_max_entries_per_row)
 +                              const size_type n_max_entries_per_row)
      :
      column_space_map (new Epetra_Map (input_map)),
      matrix (new Epetra_FECrsMatrix(Copy, *column_space_map,
  
  
  
-   SparseMatrix::SparseMatrix (const Epetra_Map &input_row_map,
-                               const Epetra_Map &input_col_map,
+   SparseMatrix::SparseMatrix (const Epetra_Map  &input_row_map,
+                               const Epetra_Map  &input_col_map,
 -                              const unsigned int n_max_entries_per_row)
 +                              const size_type n_max_entries_per_row)
      :
      column_space_map (new Epetra_Map (input_col_map)),
      matrix (new Epetra_FECrsMatrix(Copy, input_row_map,
index cea1e9f5cd7a9d992cdf86cd27ff4728c67e8119,f1d858b8d231fc6426014a08ecf143ba5479e3b6..08dcfc7df47524d6a9e9b490f5e05532b772876d
@@@ -92,8 -92,8 +92,8 @@@ namespace TrilinosWrapper
    }
  
  
-   SparsityPattern::SparsityPattern (const Epetra_Map &input_map,
+   SparsityPattern::SparsityPattern (const Epetra_Map  &input_map,
 -                                    const unsigned int n_entries_per_row)
 +                                    const size_type n_entries_per_row)
    {
      reinit (input_map, input_map, n_entries_per_row);
    }
  
  
  
-   SparsityPattern::SparsityPattern (const Epetra_Map &input_row_map,
-                                     const Epetra_Map &input_col_map,
+   SparsityPattern::SparsityPattern (const Epetra_Map  &input_row_map,
+                                     const Epetra_Map  &input_col_map,
 -                                    const unsigned int n_entries_per_row)
 +                                    const size_type n_entries_per_row)
    {
      reinit (input_row_map, input_col_map, n_entries_per_row);
    }
index ac53f93a9221dac2f447028ea38b38b919e7ed0c,badd19f289fa200a215dafbaf079543502c1f7da..9e6f68e53276671226ad1b488f21b5393e8b285e
@@@ -398,9 -397,9 +398,9 @@@ namespace TrilinosWrapper
                    const MPI_Comm &communicator)
    {
      last_action = Zero;
 -    Epetra_LocalMap map (static_cast<int>(partitioning.size()),
 +    Epetra_LocalMap map (static_cast<TrilinosWrapper::types::int_type>(partitioning.size()),
                           0,
- #ifdef DEAL_II_COMPILER_SUPPORTS_MPI
+ #ifdef DEAL_II_WITH_MPI
                           Epetra_MpiComm(communicator));
  #else
                           Epetra_SerialComm());
                    const bool      fast)
    {
      if (vector->Map().NumGlobalElements() !=
 -        static_cast<int>(partitioning.size()))
 +        static_cast<TrilinosWrapper::types::int_type>(partitioning.size()))
        {
 -        Epetra_LocalMap map (static_cast<int>(partitioning.size()),
 +        Epetra_LocalMap map (static_cast<TrilinosWrapper::types::int_type>(partitioning.size()),
                               0,
- #ifdef DEAL_II_COMPILER_SUPPORTS_MPI
+ #ifdef DEAL_II_WITH_MPI
                               Epetra_MpiComm(communicator));
  #else
                               Epetra_SerialComm());
index e5dca7807a94059d60b90e9ab1acc5dd0ee6bf2c,776031f0f55f748f3022edb412ce5709a19c8a84..14a3e2cfd435b4f6c5d677d93cc6f9860af5352a
@@@ -1122,13 -1122,13 +1122,13 @@@ namespace MatrixCreato
  
    template <int dim, int spacedim>
    void
-   create_boundary_mass_matrix (const Mapping<dim, spacedim> &mapping,
+   create_boundary_mass_matrix (const Mapping<dim, spacedim>  &mapping,
                                 const DoFHandler<dim,spacedim> &dof,
                                 const Quadrature<dim-1>  &q,
-                                SparseMatrix<double> &matrix,
-                                const typename FunctionMap<spacedim>::type &boundary_functions,
+                                SparseMatrix<double>  &matrix,
+                                const typename FunctionMap<spacedim>::type  &boundary_functions,
                                 Vector<double>            &rhs_vector,
 -                               std::vector<unsigned int> &dof_to_boundary_mapping,
 +                               std::vector<types::global_dof_index> &dof_to_boundary_mapping,
                                 const Function<spacedim> *const coefficient,
                                 std::vector<unsigned int> component_mapping)
    {
@@@ -1941,8 -1941,8 +1941,8 @@@ namespace MatrixTool
  //TODO:[WB] I don't think that the optimized storage of diagonals is needed (GK)
    template <typename number>
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          SparseMatrix<number> &matrix,
+                          SparseMatrix<number>  &matrix,
                           Vector<number>   &solution,
                           Vector<number>   &right_hand_side,
                           const bool        eliminate_columns)
  
    template <typename number>
    void
 -  apply_boundary_values (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values (const std::map<types::global_dof_index,double> &boundary_values,
-                          BlockSparseMatrix<number> &matrix,
+                          BlockSparseMatrix<number>  &matrix,
                           BlockVector<number>   &solution,
                           BlockVector<number>   &right_hand_side,
                           const bool             eliminate_columns)
@@@ -2927,30 -2927,30 +2927,30 @@@ namespace MatrixTool
  {
    template
    void
 -  apply_boundary_values<double> (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values<double> (const std::map<types::global_dof_index,double> &boundary_values,
-                                  SparseMatrix<double> &matrix,
+                                  SparseMatrix<double>  &matrix,
                                   Vector<double>   &solution,
                                   Vector<double>   &right_hand_side,
                                   const bool        eliminate_columns);
    template
    void
 -  apply_boundary_values<float> (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values<float> (const std::map<types::global_dof_index,double> &boundary_values,
-                                 SparseMatrix<float> &matrix,
+                                 SparseMatrix<float>  &matrix,
                                  Vector<float>   &solution,
                                  Vector<float>   &right_hand_side,
                                  const bool        eliminate_columns);
  
    template
    void
 -  apply_boundary_values<double> (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values<double> (const std::map<types::global_dof_index,double> &boundary_values,
-                                  BlockSparseMatrix<double> &matrix,
+                                  BlockSparseMatrix<double>  &matrix,
                                   BlockVector<double>   &solution,
                                   BlockVector<double>   &right_hand_side,
                                   const bool        eliminate_columns);
    template
    void
 -  apply_boundary_values<float> (const std::map<unsigned int,double> &boundary_values,
 +  apply_boundary_values<float> (const std::map<types::global_dof_index,double> &boundary_values,
-                                 BlockSparseMatrix<float> &matrix,
+                                 BlockSparseMatrix<float>  &matrix,
                                  BlockVector<float>   &solution,
                                  BlockVector<float>   &right_hand_side,
                                  const bool        eliminate_columns);
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge

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.