Add ParallelType argument to NumericVector::build()

The new arg defaults to AUTOMATIC, so the behavior should be exactly
the same as it was previously, although now we have the chance to set
a custom ParallelType via the NumericVector::build() API.

Author: jwpeterson

include/numerics/numeric_vector.h

@@ -139,7 +139,8 @@ class NumericVector : public ReferenceCountedObject<NumericVector<T>>,
    */
   static std::unique_ptr<NumericVector<T>>
   build(const Parallel::Communicator & comm,
-        const SolverPackage solver_package = libMesh::default_solver_package());
+        SolverPackage solver_package = libMesh::default_solver_package(),
+        ParallelType parallel_type = AUTOMATIC);
 
   /**
    * \returns \p true if the vector has been initialized,

src/numerics/numeric_vector.C

@@ -47,34 +47,36 @@ namespace libMesh
 // Full specialization for Real datatypes
 template <typename T>
 std::unique_ptr<NumericVector<T>>
-NumericVector<T>::build(const Parallel::Communicator & comm, const SolverPackage solver_package)
+NumericVector<T>::build(const Parallel::Communicator & comm,
+                        SolverPackage solver_package,
+                        ParallelType parallel_type)
 {
   // Build the appropriate vector
   switch (solver_package)
     {
 
 #ifdef LIBMESH_HAVE_LASPACK
     case LASPACK_SOLVERS:
-      return std::make_unique<LaspackVector<T>>(comm, AUTOMATIC);
+      return std::make_unique<LaspackVector<T>>(comm, parallel_type);
 #endif
 
 #ifdef LIBMESH_HAVE_PETSC
     case PETSC_SOLVERS:
-      return std::make_unique<PetscVector<T>>(comm, AUTOMATIC);
+      return std::make_unique<PetscVector<T>>(comm, parallel_type);
 #endif
 
 #ifdef LIBMESH_TRILINOS_HAVE_EPETRA
     case TRILINOS_SOLVERS:
-      return std::make_unique<EpetraVector<T>>(comm, AUTOMATIC);
+      return std::make_unique<EpetraVector<T>>(comm, parallel_type);
 #endif
 
 #ifdef LIBMESH_HAVE_EIGEN
     case EIGEN_SOLVERS:
-      return std::make_unique<EigenSparseVector<T>>(comm, AUTOMATIC);
+      return std::make_unique<EigenSparseVector<T>>(comm, parallel_type);
 #endif
 
     default:
-      return std::make_unique<DistributedVector<T>>(comm, AUTOMATIC);
+      return std::make_unique<DistributedVector<T>>(comm, parallel_type);
     }
 }
 

src/systems/system.C

@@ -792,19 +792,28 @@ NumericVector<Number> & System::add_vector (std::string_view vec_name,
                   vec.swap(*new_vec);
                 }
               else
-                vec.type() = type;
+                // The PARALLEL vec is not yet initialized, so we can just "upgrade" it to GHOSTED
+                vec.upgrade_to_ghosted();
             }
         }
 
       // Any upgrades are done; we're happy here.
       return vec;
     }
 
-  // Otherwise build the vector
-  auto pr = _vectors.emplace(vec_name, NumericVector<Number>::build(this->comm()));
+  // Otherwise, build the vector. The following emplace() is
+  // guaranteed to succeed because, if we made it here, we don't
+  // already have a vector named "vec_name". We pass the user's
+  // requested ParallelType directly to NumericVector::build() so
+  // that, even if the vector is not initialized now, it will get the
+  // right type when it is initialized later.
+  auto pr =
+    _vectors.emplace(vec_name,
+                     NumericVector<Number>::build(this->comm(),
+                                                  libMesh::default_solver_package(),
+                                                  type));
   auto buf = pr.first->second.get();
   _vector_projections.emplace(vec_name, projections);
-  buf->type() = type;
 
   // Vectors are primal by default
   _vector_is_adjoint.emplace(vec_name, -1);