]> https://gitweb.dealii.org/ - dealii.git/commitdiff
locally_owned_size in LA::D::Vector
authorDavid Wells <drwells@email.unc.edu>
Mon, 25 May 2020 16:22:18 +0000 (12:22 -0400)
committerDaniel Arndt <arndtd@ornl.gov>
Thu, 11 Feb 2021 16:52:47 +0000 (11:52 -0500)
include/deal.II/lac/la_parallel_vector.h
include/deal.II/lac/la_parallel_vector.templates.h
include/deal.II/lac/precondition.h
include/deal.II/lac/trilinos_precondition.h
include/deal.II/matrix_free/cuda_matrix_free.templates.h
include/deal.II/multigrid/mg_transfer.templates.h
include/deal.II/multigrid/mg_transfer_matrix_free.h
source/lac/petsc_parallel_vector.cc
source/multigrid/mg_transfer_matrix_free.cc

index a9f50291b548e8734fae54232e5c4c1686647441..c07e8016d1fd8c867243a3e4a5109ec940cde917 100644 (file)
@@ -1689,7 +1689,7 @@ namespace LinearAlgebra
                        partitioner->locally_owned_size() +
                          partitioner->n_ghost_indices());
       // do not allow reading a vector which is not in ghost mode
-      Assert(local_index < local_size() || vector_is_ghosted == true,
+      Assert(local_index < locally_owned_size() || vector_is_ghosted == true,
              ExcMessage("You tried to read a ghost element of this vector, "
                         "but it has not imported its ghost values."));
 
index f41ff44c524264938d64afa37929c5993e289b97..ca7af1eb7d2e73dda50c39d09932143beeb3d495 100644 (file)
@@ -695,7 +695,7 @@ namespace LinearAlgebra
 
       thread_loop_partitioner = v.thread_loop_partitioner;
 
-      const size_type this_size = local_size();
+      const size_type this_size = locally_owned_size();
       if (this_size > 0)
         {
           dealii::internal::VectorOperations::
@@ -1316,7 +1316,7 @@ namespace LinearAlgebra
         }
       Vector<Number, ::dealii::MemorySpace::Host> tmp_vector(comm_pattern);
 
-      data.copy_to(tmp_vector.begin(), local_size());
+      data.copy_to(tmp_vector.begin(), locally_owned_size());
 
       // fill entries from ReadWriteVector into the distributed vector,
       // including ghost entries. this is not really efficient right now
@@ -1365,7 +1365,7 @@ namespace LinearAlgebra
         }
       tmp_vector.compress(operation);
 
-      data.copy_from(tmp_vector.begin(), local_size());
+      data.copy_from(tmp_vector.begin(), locally_owned_size());
     }
 
     template <typename Number, typename MemorySpaceType>
@@ -1424,7 +1424,7 @@ namespace LinearAlgebra
     Vector<Number, MemorySpaceType> &
     Vector<Number, MemorySpaceType>::operator=(const Number s)
     {
-      const size_type this_size = local_size();
+      const size_type this_size = locally_owned_size();
       if (this_size > 0)
         {
           dealii::internal::VectorOperations::
@@ -1469,7 +1469,7 @@ namespace LinearAlgebra
              ExcVectorTypeNotCompatible());
       const VectorType &v = dynamic_cast<const VectorType &>(vv);
 
-      AssertDimension(local_size(), v.local_size());
+      AssertDimension(locally_owned_size(), v.locally_owned_size());
 
       dealii::internal::VectorOperations::
         functions<Number, Number, MemorySpaceType>::add_vector(
@@ -1497,7 +1497,7 @@ namespace LinearAlgebra
              ExcVectorTypeNotCompatible());
       const VectorType &v = dynamic_cast<const VectorType &>(vv);
 
-      AssertDimension(local_size(), v.local_size());
+      AssertDimension(locally_owned_size(), v.locally_owned_size());
 
       dealii::internal::VectorOperations::
         functions<Number, Number, MemorySpaceType>::subtract_vector(
@@ -1543,7 +1543,7 @@ namespace LinearAlgebra
       const VectorType &v = dynamic_cast<const VectorType &>(vv);
 
       AssertIsFinite(a);
-      AssertDimension(local_size(), v.local_size());
+      AssertDimension(locally_owned_size(), v.locally_owned_size());
 
       // nothing to do if a is zero
       if (a == Number(0.))
@@ -1592,8 +1592,8 @@ namespace LinearAlgebra
       AssertIsFinite(a);
       AssertIsFinite(b);
 
-      AssertDimension(local_size(), v.local_size());
-      AssertDimension(local_size(), w.local_size());
+      AssertDimension(locally_owned_size(), v.locally_owned_size());
+      AssertDimension(locally_owned_size(), w.locally_owned_size());
 
       dealii::internal::VectorOperations::
         functions<Number, Number, MemorySpaceType>::add_avpbw(
@@ -1631,7 +1631,7 @@ namespace LinearAlgebra
       const Vector<Number, MemorySpaceType> &v)
     {
       AssertIsFinite(x);
-      AssertDimension(local_size(), v.local_size());
+      AssertDimension(locally_owned_size(), v.locally_owned_size());
 
       dealii::internal::VectorOperations::
         functions<Number, Number, MemorySpaceType>::sadd_xv(
@@ -1662,7 +1662,7 @@ namespace LinearAlgebra
 
       AssertIsFinite(x);
       AssertIsFinite(a);
-      AssertDimension(local_size(), v.local_size());
+      AssertDimension(locally_owned_size(), v.locally_owned_size());
 
       dealii::internal::VectorOperations::
         functions<Number, Number, MemorySpaceType>::sadd_xav(
@@ -1731,11 +1731,11 @@ namespace LinearAlgebra
              ExcVectorTypeNotCompatible());
       const VectorType &v = dynamic_cast<const VectorType &>(vv);
 
-      AssertDimension(local_size(), v.local_size());
+      AssertDimension(locally_owned_size(), v.locally_owned_size());
 
       dealii::internal::VectorOperations::
         functions<Number, Number, MemorySpaceType>::scale(
-          thread_loop_partitioner, local_size(), v.data, data);
+          thread_loop_partitioner, locally_owned_size(), v.data, data);
 
       if (vector_is_ghosted)
         update_ghost_values();
@@ -1755,7 +1755,7 @@ namespace LinearAlgebra
       const VectorType &v = dynamic_cast<const VectorType &>(vv);
 
       AssertIsFinite(a);
-      AssertDimension(local_size(), v.local_size());
+      AssertDimension(locally_owned_size(), v.locally_owned_size());
 
       dealii::internal::VectorOperations::
         functions<Number, Number, MemorySpaceType>::equ_au(
@@ -1975,10 +1975,10 @@ namespace LinearAlgebra
     {
       real_type max = 0.;
 
-      const size_type local_size = partitioner->locally_owned_size();
+      const size_type locally_owned_size = partitioner->locally_owned_size();
       internal::la_parallel_vector_templates_functions<
         Number,
-        MemorySpaceType>::linfty_norm_local(data, local_size, max);
+        MemorySpaceType>::linfty_norm_local(data, locally_owned_size, max);
 
       return max;
     }
@@ -2007,8 +2007,8 @@ namespace LinearAlgebra
       const Vector<Number, MemorySpaceType> &w)
     {
       const size_type vec_size = partitioner->locally_owned_size();
-      AssertDimension(vec_size, v.local_size());
-      AssertDimension(vec_size, w.local_size());
+      AssertDimension(vec_size, v.locally_owned_size());
+      AssertDimension(vec_size, w.locally_owned_size());
 
       Number sum = dealii::internal::VectorOperations::
         functions<Number, Number, MemorySpaceType>::add_and_dot(
index d620a1e259bef26eca2d93b96f4ce2e7d1c69424..b991207efe24630c39e326f63c6d9e17b8644d51 100644 (file)
@@ -2009,7 +2009,7 @@ namespace internal
                                 solution_old.begin(),
                                 temp_vector1.begin(),
                                 solution.begin());
-      VectorUpdatesRange<Number>(upd, rhs.local_size());
+      VectorUpdatesRange<Number>(upd, rhs.locally_owned_size());
 
       // swap vectors x^{n+1}->x^{n}, given the updates in the function above
       if (iteration_index == 0)
@@ -2102,7 +2102,7 @@ namespace internal
       types::global_dof_index first_local_range = 0;
       if (!vector.locally_owned_elements().is_empty())
         first_local_range = vector.locally_owned_elements().nth_index_in_set(0);
-      for (unsigned int i = 0; i < vector.local_size(); ++i)
+      for (unsigned int i = 0; i < vector.locally_owned_size(); ++i)
         vector.local_element(i) = (i + first_local_range) % 11;
 
       const Number mean_value = vector.mean_value();
@@ -2148,7 +2148,7 @@ namespace internal
       if (!vector.locally_owned_elements().is_empty())
         first_local_range = vector.locally_owned_elements().nth_index_in_set(0);
 
-      const auto n_local_elements = vector.local_size();
+      const auto n_local_elements = vector.locally_owned_size();
       const int  n_blocks =
         1 + (n_local_elements - 1) / CUDAWrappers::block_size;
       set_initial_guess_kernel<<<n_blocks, CUDAWrappers::block_size>>>(
index e4b5b471eb22cad5f485e328f32d848d76b10209..f2bad01524c56dd7fe2840f8f644747fe17c918c 100644 (file)
@@ -2141,9 +2141,9 @@ namespace TrilinosWrappers
     LinearAlgebra::distributed::Vector<double> &      dst,
     const LinearAlgebra::distributed::Vector<double> &src) const
   {
-    AssertDimension(dst.local_size(),
+    AssertDimension(dst.locally_owned_size(),
                     preconditioner->OperatorDomainMap().NumMyElements());
-    AssertDimension(src.local_size(),
+    AssertDimension(src.locally_owned_size(),
                     preconditioner->OperatorRangeMap().NumMyElements());
     Epetra_Vector tril_dst(View,
                            preconditioner->OperatorDomainMap(),
@@ -2161,9 +2161,9 @@ namespace TrilinosWrappers
     LinearAlgebra::distributed::Vector<double> &      dst,
     const LinearAlgebra::distributed::Vector<double> &src) const
   {
-    AssertDimension(dst.local_size(),
+    AssertDimension(dst.locally_owned_size(),
                     preconditioner->OperatorDomainMap().NumMyElements());
-    AssertDimension(src.local_size(),
+    AssertDimension(src.locally_owned_size(),
                     preconditioner->OperatorRangeMap().NumMyElements());
     Epetra_Vector tril_dst(View,
                            preconditioner->OperatorDomainMap(),
index b2b8bc70c2d08df95e252ee07e5e991e377fd4d6..7d3f8c2e1e9eefcf5671b61039447c996c027409 100644 (file)
@@ -1293,7 +1293,7 @@ namespace CUDAWrappers
     internal::copy_constrained_dofs<Number>
       <<<constraint_grid_dim, constraint_block_dim>>>(constrained_dofs,
                                                       n_constrained_dofs,
-                                                      src.local_size(),
+                                                      src.locally_owned_size(),
                                                       src.get_values(),
                                                       dst.get_values());
     AssertCudaKernel();
@@ -1338,7 +1338,7 @@ namespace CUDAWrappers
     internal::set_constrained_dofs<Number>
       <<<constraint_grid_dim, constraint_block_dim>>>(constrained_dofs,
                                                       n_constrained_dofs,
-                                                      dst.local_size(),
+                                                      dst.locally_owned_size(),
                                                       val,
                                                       dst.get_values());
     AssertCudaKernel();
index 87eb8ee0f7c35fd60d226fba03ce9898b1310f94..3554957ffec0b387a9b54de9b4316e5f9dd005ab 100644 (file)
@@ -432,7 +432,7 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_to_mg(
 
   for (unsigned int level = dst.min_level(); level <= dst.max_level(); ++level)
     if (dst[level].size() != dof_handler.n_dofs(level) ||
-        dst[level].local_size() !=
+        dst[level].locally_owned_size() !=
           dof_handler.locally_owned_mg_dofs(level).n_elements())
       {
         // In case a ghosted level vector has been initialized, we can simply
@@ -460,14 +460,17 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_to_mg(
   if (perform_plain_copy)
     {
       // In this case, we can simply copy the local range.
-      AssertDimension(dst[dst.max_level()].local_size(), src.local_size());
+      AssertDimension(dst[dst.max_level()].locally_owned_size(),
+                      src.locally_owned_size());
       dst[dst.max_level()].copy_locally_owned_data_from(src);
       return;
     }
   else if (perform_renumbered_plain_copy)
     {
-      AssertDimension(dst[dst.max_level()].local_size(), src.local_size());
-      AssertDimension(this_copy_indices.back().n_cols(), src.local_size());
+      AssertDimension(dst[dst.max_level()].locally_owned_size(),
+                      src.locally_owned_size());
+      AssertDimension(this_copy_indices.back().n_cols(),
+                      src.locally_owned_size());
       Assert(copy_indices_level_mine.back().n_rows() == 0, ExcInternalError());
       LinearAlgebra::distributed::Vector<Number> &dst_level =
         dst[dst.max_level()];
@@ -482,7 +485,8 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_to_mg(
 
   // the ghosted vector should already have the correct local size (but
   // different parallel layout)
-  AssertDimension(ghosted_global_vector.local_size(), src.local_size());
+  AssertDimension(ghosted_global_vector.locally_owned_size(),
+                  src.locally_owned_size());
 
   // copy the source vector to the temporary vector that we hold for the
   // purpose of data exchange
@@ -532,14 +536,16 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_from_mg(
       // stray data in ghost entries of the destination, make sure to clear
       // them here.
       dst.zero_out_ghost_values();
-      AssertDimension(src[src.max_level()].local_size(), dst.local_size());
+      AssertDimension(src[src.max_level()].locally_owned_size(),
+                      dst.locally_owned_size());
       dst.copy_locally_owned_data_from(src[src.max_level()]);
       return;
     }
   else if (perform_renumbered_plain_copy)
     {
-      AssertDimension(src[src.max_level()].local_size(), dst.local_size());
-      AssertDimension(copy_indices.back().n_cols(), dst.local_size());
+      AssertDimension(src[src.max_level()].locally_owned_size(),
+                      dst.locally_owned_size());
+      AssertDimension(copy_indices.back().n_cols(), dst.locally_owned_size());
       Assert(copy_indices_global_mine.back().n_rows() == 0, ExcInternalError());
       Assert(copy_indices_global_mine.back().empty(), ExcInternalError());
       const LinearAlgebra::distributed::Vector<Number> &src_level =
@@ -560,8 +566,8 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::copy_from_mg(
     {
       // the ghosted vector should already have the correct local size (but
       // different parallel layout)
-      AssertDimension(ghosted_level_vector[level].local_size(),
-                      src[level].local_size());
+      AssertDimension(ghosted_level_vector[level].locally_owned_size(),
+                      src[level].locally_owned_size());
 
       // the first time around, we copy the source vector to the temporary
       // vector that we hold for the purpose of data exchange
@@ -607,8 +613,8 @@ MGLevelGlobalTransfer<LinearAlgebra::distributed::Vector<Number>>::
     {
       // the ghosted vector should already have the correct local size (but
       // different parallel layout)
-      AssertDimension(ghosted_level_vector[level].local_size(),
-                      src[level].local_size());
+      AssertDimension(ghosted_level_vector[level].locally_owned_size(),
+                      src[level].locally_owned_size());
 
       // the first time around, we copy the source vector to the temporary
       // vector that we hold for the purpose of data exchange
index 48cdb2e5e41c8a819f5520e232b1565dff0a8c7b..8c71361164d04529d2cec4a28c76295fc939152f 100644 (file)
@@ -507,7 +507,7 @@ MGTransferMatrixFree<dim, Number>::interpolate_to_mg(
 
   for (unsigned int level = min_level; level <= max_level; ++level)
     if (dst[level].size() != dof_handler.n_dofs(level) ||
-        dst[level].local_size() !=
+        dst[level].locally_owned_size() !=
           dof_handler.locally_owned_mg_dofs(level).n_elements())
       dst[level].reinit(this->vector_partitioners[level]);
 
@@ -643,7 +643,7 @@ MGTransferBlockMatrixFree<dim, Number>::copy_to_mg(
             LinearAlgebra::distributed::Vector<Number> &v = dst[level].block(b);
             if (v.size() !=
                   dof_handler[b]->locally_owned_mg_dofs(level).size() ||
-                v.local_size() !=
+                v.locally_owned_size() !=
                   dof_handler[b]->locally_owned_mg_dofs(level).n_elements())
               {
                 do_reinit[level] = true;
index 31539c03da5644a34fa22a2c0fada849838f5a40..e370c65667a37875324758854ba2fbacf1f7ee32 100644 (file)
@@ -257,8 +257,10 @@ namespace PETScWrappers
       AssertIndexRange(locally_owned_size, n + 1);
       ghosted = false;
 
-      const PetscErrorCode ierr =
-        VecCreateMPI(communicator, locally_owned_size, PETSC_DETERMINE, &vector);
+      const PetscErrorCode ierr = VecCreateMPI(communicator,
+                                               locally_owned_size,
+                                               PETSC_DETERMINE,
+                                               &vector);
       AssertThrow(ierr == 0, ExcPETScError(ierr));
 
       Assert(size() == n, ExcDimensionMismatch(size(), n));
@@ -302,7 +304,8 @@ namespace PETScWrappers
         ierr = VecGetOwnershipRange(vector, &begin, &end);
         AssertThrow(ierr == 0, ExcPETScError(ierr));
 
-        AssertDimension(locally_owned_size, static_cast<size_type>(end - begin));
+        AssertDimension(locally_owned_size,
+                        static_cast<size_type>(end - begin));
 
         Vec l;
         ierr = VecGhostGetLocalForm(vector, &l);
index 6da035520ed07633743548a2120d0263ed80d5c7..d1cc31f16d1ba330679cc09661d7cba7d24d2aaf 100644 (file)
@@ -208,8 +208,8 @@ MGTransferMatrixFree<dim, Number>::prolongate(
           this->vector_partitioners[to_level].get())
         this->ghosted_level_vector[to_level].reinit(
           this->vector_partitioners[to_level]);
-      AssertDimension(this->ghosted_level_vector[to_level].local_size(),
-                      dst.local_size());
+      AssertDimension(this->ghosted_level_vector[to_level].locally_owned_size(),
+                      dst.locally_owned_size());
     }
 
   const LinearAlgebra::distributed::Vector<Number> &src_vec =
@@ -287,8 +287,9 @@ MGTransferMatrixFree<dim, Number>::restrict_and_add(
           this->vector_partitioners[from_level - 1].get())
         this->ghosted_level_vector[from_level - 1].reinit(
           this->vector_partitioners[from_level - 1]);
-      AssertDimension(this->ghosted_level_vector[from_level - 1].local_size(),
-                      dst.local_size());
+      AssertDimension(
+        this->ghosted_level_vector[from_level - 1].locally_owned_size(),
+        dst.locally_owned_size());
       this->ghosted_level_vector[from_level - 1] = 0.;
     }
 

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.