Merge 'trilinos/Trilinos:develop' (dcc6bcb) into 'tcad-charon/Trilino…

…s:develop' (649d31e).

* trilinos-develop:
  Teuchos::ParameterList: Fix trilinos#5127 (trilinos#5128)
  MueLu:print msg if coarseSolver not setup properly
  swap gcc module in sems-rhel6 intel-17 builds
  Stokhos:  Fix tpetra link order.
  Add driver for waterman_cuda-9.2_fpic_static_opt testing and installs for SPARC (ATDV-151)
  Add support for 'fpic' build name keyword (ATDV-151)
  MueLu: Fixing shadow error
  MueLu: fix type issues in LineDetetion factory, see issue trilinos#5112
  MueLu: Ray's fixies to RAPShiftFactory

cmake/ctest/drivers/atdm/waterman/drivers/Trilinos-atdm-waterman_cuda-9.2_fpic_static_opt.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+if [ "${Trilinos_TRACK}" == "" ] ; then
+  export Trilinos_TRACK=Specialized
+fi
+$WORKSPACE/Trilinos/cmake/ctest/drivers/atdm/waterman/local-driver.sh

cmake/std/atdm/ATDMDevEnvSettings.cmake

@@ -53,6 +53,7 @@ ATDM_SET_ATDM_VAR_FROM_ENV_AND_DEFAULT(USE_OPENMP OFF)
 ATDM_SET_ATDM_VAR_FROM_ENV_AND_DEFAULT(USE_PTHREADS OFF)
 ATDM_SET_ATDM_VAR_FROM_ENV_AND_DEFAULT(USE_CUDA OFF)
 ATDM_SET_ATDM_VAR_FROM_ENV_AND_DEFAULT(CUDA_RDC OFF)
+ATDM_SET_ATDM_VAR_FROM_ENV_AND_DEFAULT(FPIC OFF)
 ATDM_SET_ATDM_VAR_FROM_ENV_AND_DEFAULT(COMPLEX OFF)
 
 SET(ATDM_INST_SERIAL OFF)
@@ -176,8 +177,16 @@ ATDM_SET_CACHE(BUILD_SHARED_LIBS "${ATDM_SHARED_LIBS}" CACHE BOOL)
 ATDM_SET_CACHE(CMAKE_BUILD_TYPE "${ATDM_CMAKE_BUILD_TYPE}" CACHE STRING)
 
 SET(EXTRA_EXTRA_CXX_FLAGS)
+# RDC
 IF (ATDM_USE_CUDA AND ATDM_CUDA_RDC)
-  SET(EXTRA_EXTRA_CXX_FLAGS " --remove-duplicate-link-files")
+  SET(EXTRA_EXTRA_CXX_FLAGS "${EXTRA_EXTRA_CXX_FLAGS} --remove-duplicate-link-files")
+  # To get around defect in TriBITS where it will add duplicate libs if a
+  # downstream package add dependencies on both a subpackage and its parent
+  # package.
+ENDIF()
+# FPIC
+IF (ATDM_FPIC)
+  SET(EXTRA_EXTRA_CXX_FLAGS "${EXTRA_EXTRA_CXX_FLAGS} -fPIC")
   # To get around defect in TriBITS where it will add duplicate libs if a
   # downstream package add dependencies on both a subpackage and its parent
   # package.

cmake/std/atdm/README.md

@@ -86,9 +86,9 @@ build name strings [below](#build-name-examples).
 
 Each of these keywords [`<system_name>`](#system_name),
 [`<kokkos_arch>`](#kokkos_arch), [`<compiler>`](#compiler),
-[`<kokkos_thread>`](#kokkos_thread), [`<rdc>`](#rdc), [`<complex>`](#complex),
-[`<shared_static>`](#shared_static), [`<release_debug>`](#release_debug), and
-[`<pt>`](#pt), are described below.
+[`<kokkos_thread>`](#kokkos_thread), [`<rdc>`](#rdc), [`<fpic>`](#fpic),
+[`<complex>`](#complex), [`<shared_static>`](#shared_static),
+[`<release_debug>`](#release_debug), and [`<pt>`](#pt), are described below.
 
 <a name="system_name"/>
 
@@ -184,6 +184,13 @@ builds (does nothing in non-CUDA builds):
 NOTE: Setting `rdc` also currently adds the `nvcc_wrapper` option
 `--remove-duplicate-link-files` as well.
 
+<a name="fpic"/>
+
+**`<fpic>`:** The following `<build-name>` keyword will result in `-fPIC`
+being added to `CMAKE_CXX_FLAGS`:
+
+* `fpic`: Add `-fPIC` to `CMAKE_CXX_FLAGS`
+
 <a name="complex"/>
 
 **`<complex>`:** The following `<build-name>` keywords determine if support

cmake/std/atdm/sems-rhel6/environment.sh

@@ -147,6 +147,7 @@ elif [[ "$ATDM_CONFIG_COMPILER" == "GNU-7.2.0" ]] ; then
   export ATDM_CONFIG_BLAS_LIBS="-L${BLAS_ROOT}/lib;-lblas"
 elif [[ "$ATDM_CONFIG_COMPILER" == "INTEL-17.0.1" ]] ; then
   module load sems-intel/17.0.1
+  module swap sems-gcc/4.8.4 sems-gcc/4.9.3
   export OMPI_CXX=`which icpc`
   export OMPI_CC=`which icc`
   export OMPI_FC=`which ifort`

cmake/std/atdm/utils/set_build_options.sh

@@ -18,6 +18,7 @@
 #   ATDM_CONFIG_USE_CUDA
 #   ATDM_CONFIG_USE_PTHREADS
 #   ATDM_CONFIG_CUDA_RDC
+#   ATDM_CONFIG_FPIC
 #   ATDM_CONFIG_COMPLEX
 #   ATDM_CONFIG_SHARED_LIBS
 #   ATDM_CONFIG_PT_PACKAGES
@@ -53,7 +54,7 @@ fi
 ATDM_UTILS_SCRIPT_DIR=`echo $BASH_SOURCE | sed "s/\(.*\)\/.*\.sh/\1/g"`
 export ATDM_CONFIG_SCRIPT_DIR=`readlink -f ${ATDM_UTILS_SCRIPT_DIR}/..`
 
-echo "Setting compiler and build options for buld name '${ATDM_CONFIG_BUILD_NAME}'"
+echo "Setting compiler and build options for build-name '${ATDM_CONFIG_BUILD_NAME}'"
 
 # Set the defaults
 export ATDM_CONFIG_COMPILER=DEFAULT
@@ -249,6 +250,13 @@ elif [[ $ATDM_CONFIG_BUILD_NAME == *"-rdc"* ]] \
   export ATDM_CONFIG_CUDA_RDC=ON
 fi
 
+# Use -fPIC or not
+export ATDM_CONFIG_FPIC=OFF
+if [[ $ATDM_CONFIG_BUILD_NAME == *"-fpic"* ]] \
+  || [[ $ATDM_CONFIG_BUILD_NAME == *"_fpic"* ]]; then
+  export ATDM_CONFIG_FPIC=ON
+fi
+
 # Enable complex (double) data-types or not
 export ATDM_CONFIG_COMPLEX=OFF
 if [[ $ATDM_CONFIG_BUILD_NAME == *"no-complex"* ]]; then

cmake/std/atdm/utils/unset_atdm_config_vars_build_options.sh

@@ -11,6 +11,7 @@ unset ATDM_CONFIG_USE_OPENMP
 unset ATDM_CONFIG_USE_CUDA
 unset ATDM_CONFIG_USE_PTHREADS
 unset ATDM_CONFIG_CUDA_RDC
+unset ATDM_CONFIG_FPIC
 unset ATDM_CONFIG_COMPLEX
 unset ATDM_CONFIG_SHARED_LIBS
 unset ATDM_CONFIG_PT_PACKAGES

packages/muelu/research/mmayr/composite_to_regions/src/SetupRegionHierarchy_def.hpp

@@ -1714,10 +1714,20 @@ void vCycle(const int l, ///< ID of current level
   RCP<const Tpetra_MultiVector> tB = Utilities::MV2TpetraMV(compRhs);
 
   /* Solve!
+   *
+   * Calling solve() on the coarseSolver sould just do a triangular solve, since symbolic
+   * and numeric factorization are supposed to have happened during hierarchy setup.
+   * Here, we just check if they're done and print message if not.
    *
    * We don't have to change the map of tX and tB since we have configured the Amesos2 solver
    * during its construction to work with non-continous maps.
    */
+  if (not coarseSolver->getStatus().symbolicFactorizationDone())
+    *fos << "Symbolic factorization should have been done during hierarchy setup, "
+        "but actually is missing. Anyway ... just do it right now." << std::endl;
+  if (not coarseSolver->getStatus().numericFactorizationDone())
+    *fos << "Numeric factorization should have been done during hierarchy setup, "
+        "but actually is missing. Anyway ... just do it right now." << std::endl;
   coarseSolver->solve(tX.ptr(), tB.ptr());
 
   // Transform back to region format

packages/muelu/src/Misc/MueLu_LineDetectionFactory_decl.hpp

@@ -71,6 +71,9 @@ namespace MueLu {
 
   public:
 
+    using coordinate_type       = typename Teuchos::ScalarTraits<SC>::coordinateType;
+    using CoordinateMultiVector = typename Xpetra::MultiVector<coordinate_type, LO, GO, NO>;
+
     //! @name Constructors/Destructors.
     //@{
 
@@ -103,15 +106,22 @@ namespace MueLu {
     //@}
 
   private:
-    void sort_coordinates(LO numCoords, LO* OrigLoc, Scalar* xvals, Scalar* yvals, Scalar* zvals, Scalar* xtemp, Scalar* ytemp, Scalar* ztemp, bool flipXY = false) const;
+    void sort_coordinates(LO numCoords, LO* OrigLoc,
+                          coordinate_type* xvals,
+                          coordinate_type* yvals,
+                          coordinate_type* zvals,
+                          coordinate_type* xtemp,
+                          coordinate_type* ytemp,
+                          coordinate_type* ztemp,
+                          bool flipXY = false) const;
 
     LO ML_compute_line_info(LO LayerId[], LO VertLineId[],
-                                      LO Ndof, LO DofsPerNode,
-                                      LO MeshNumbering, LO NumNodesPerVertLine,
-                                      SC *xvals, SC *yvals, SC *zvals,
-                                      const Teuchos::Comm<int>& comm ) const ;
+                            LO Ndof, LO DofsPerNode,
+                            LO MeshNumbering, LO NumNodesPerVertLine,
+                            coordinate_type *xvals, coordinate_type *yvals, coordinate_type *zvals,
+                            const Teuchos::Comm<int>& comm ) const ;
 
-    void ML_az_dsort2(SC dlist[], LO N, LO list2[]) const;
+    void ML_az_dsort2(coordinate_type dlist[], LO N, LO list2[]) const;
 
     //! internally stores line detection mode
     //! can be either vertical, horizontal or coordinates

packages/muelu/src/Misc/MueLu_LineDetectionFactory_def.hpp

@@ -93,9 +93,9 @@ namespace MueLu {
     FactoryMonitor m(*this, "Line detection (Ray style)", currentLevel);
 
     LO               NumZDir = 0;
-    RCP<MultiVector> fineCoords;
-    ArrayRCP<Scalar> x, y, z;
-    Scalar           *xptr = NULL, *yptr = NULL, *zptr = NULL;
+    RCP<CoordinateMultiVector> fineCoords;
+    ArrayRCP<coordinate_type>  x, y, z;
+    coordinate_type            *xptr = NULL, *yptr = NULL, *zptr = NULL;
 
     // obtain general variables
     RCP<Matrix> A         = Get< RCP<Matrix> >      (currentLevel, "A");
@@ -137,7 +137,7 @@ namespace MueLu {
 
           if (CoordsAvail == true) {
             // try to reconstruct the number of layers from coordinates
-            fineCoords = Get< RCP<MultiVector> > (currentLevel, "Coordinates");
+            fineCoords = Get< RCP<CoordinateMultiVector> > (currentLevel, "Coordinates");
             TEUCHOS_TEST_FOR_EXCEPTION(fineCoords->getNumVectors() != 3, Exceptions::RuntimeError, "Three coordinates arrays must be supplied if line detection orientation not given.");
             x = fineCoords->getDataNonConst(0);
             y = fineCoords->getDataNonConst(1);
@@ -150,9 +150,9 @@ namespace MueLu {
 
             /* sort coordinates so that we can order things according to lines */
             Teuchos::ArrayRCP<LO> TOrigLoc= Teuchos::arcp<LO>(NumCoords);   LO* OrigLoc= TOrigLoc.getRawPtr();
-            Teuchos::ArrayRCP<SC> Txtemp  = Teuchos::arcp<SC>(NumCoords);   SC* xtemp  = Txtemp.getRawPtr();
-            Teuchos::ArrayRCP<SC> Tytemp  = Teuchos::arcp<SC>(NumCoords);   SC* ytemp  = Tytemp.getRawPtr();
-            Teuchos::ArrayRCP<SC> Tztemp  = Teuchos::arcp<SC>(NumCoords);   SC* ztemp  = Tztemp.getRawPtr();
+            Teuchos::ArrayRCP<coordinate_type> Txtemp  = Teuchos::arcp<coordinate_type>(NumCoords);   coordinate_type* xtemp  = Txtemp.getRawPtr();
+            Teuchos::ArrayRCP<coordinate_type> Tytemp  = Teuchos::arcp<coordinate_type>(NumCoords);   coordinate_type* ytemp  = Tytemp.getRawPtr();
+            Teuchos::ArrayRCP<coordinate_type> Tztemp  = Teuchos::arcp<coordinate_type>(NumCoords);   coordinate_type* ztemp  = Tztemp.getRawPtr();
 
             // sort coordinates in {x,y,z}vals (returned in {x,y,z}temp) so that we can order things according to lines
             // switch x and y coordinates for semi-coarsening...
@@ -165,7 +165,7 @@ namespace MueLu {
             LO index = 0;
 
             while ( index < NumCoords ) {
-              SC xfirst = xtemp[index]; SC yfirst = ytemp[index];
+              coordinate_type xfirst = xtemp[index]; coordinate_type yfirst = ytemp[index];
               LO next = index+1;
               while ( (next != NumCoords) && (xtemp[next] == xfirst) &&
                       (ytemp[next] == yfirst))
@@ -210,7 +210,7 @@ namespace MueLu {
         else
           throw Exceptions::RuntimeError("Coordinates not generated by previous invocation of LineDetectionFactory's BuildP() method.");
       }
-      fineCoords = Get< RCP<MultiVector> > (currentLevel, "Coordinates");
+      fineCoords = Get< RCP<CoordinateMultiVector> > (currentLevel, "Coordinates");
       TEUCHOS_TEST_FOR_EXCEPTION(fineCoords->getNumVectors() != 3, Exceptions::RuntimeError, "Three coordinates arrays must be supplied if line detection orientation not given.");
       x = fineCoords->getDataNonConst(0);
       y = fineCoords->getDataNonConst(1);
@@ -253,12 +253,12 @@ namespace MueLu {
   }
 
   template <class Scalar,class LocalOrdinal, class GlobalOrdinal, class Node>
-  LocalOrdinal LineDetectionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::ML_compute_line_info(LocalOrdinal LayerId[], LocalOrdinal VertLineId[], LocalOrdinal Ndof, LocalOrdinal DofsPerNode, LocalOrdinal MeshNumbering, LocalOrdinal NumNodesPerVertLine, Scalar *xvals, Scalar *yvals, Scalar *zvals, const Teuchos::Comm<int>& /* comm */) const {
+  LocalOrdinal LineDetectionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::ML_compute_line_info(LocalOrdinal LayerId[], LocalOrdinal VertLineId[], LocalOrdinal Ndof, LocalOrdinal DofsPerNode, LocalOrdinal MeshNumbering, LocalOrdinal NumNodesPerVertLine, typename Teuchos::ScalarTraits<Scalar>::coordinateType *xvals, typename Teuchos::ScalarTraits<Scalar>::coordinateType *yvals, typename Teuchos::ScalarTraits<Scalar>::coordinateType *zvals, const Teuchos::Comm<int>& /* comm */) const {
 
     LO    Nnodes, NVertLines, MyNode;
     LO    NumCoords, next; //, subindex, subnext;
-    SC xfirst, yfirst;
-    SC *xtemp, *ytemp, *ztemp;
+    coordinate_type xfirst, yfirst;
+    coordinate_type *xtemp, *ytemp, *ztemp;
     LO    *OrigLoc;
     LO    i,j,count;
     LO    RetVal;
@@ -301,9 +301,9 @@ namespace MueLu {
 
       // reserve temporary memory
       Teuchos::ArrayRCP<LO> TOrigLoc= Teuchos::arcp<LO>(NumCoords);       OrigLoc= TOrigLoc.getRawPtr();
-      Teuchos::ArrayRCP<SC> Txtemp  = Teuchos::arcp<SC>(NumCoords);       xtemp  = Txtemp.getRawPtr();
-      Teuchos::ArrayRCP<SC> Tytemp  = Teuchos::arcp<SC>(NumCoords);       ytemp  = Tytemp.getRawPtr();
-      Teuchos::ArrayRCP<SC> Tztemp  = Teuchos::arcp<SC>(NumCoords);       ztemp  = Tztemp.getRawPtr();
+      Teuchos::ArrayRCP<coordinate_type> Txtemp  = Teuchos::arcp<coordinate_type>(NumCoords);       xtemp  = Txtemp.getRawPtr();
+      Teuchos::ArrayRCP<coordinate_type> Tytemp  = Teuchos::arcp<coordinate_type>(NumCoords);       ytemp  = Tytemp.getRawPtr();
+      Teuchos::ArrayRCP<coordinate_type> Tztemp  = Teuchos::arcp<coordinate_type>(NumCoords);       ztemp  = Tztemp.getRawPtr();
 
       // build vertical line info for semi-coarsening
 
@@ -357,7 +357,14 @@ namespace MueLu {
 
   /* Private member function to sort coordinates in arrays. This is an expert routine. Do not use or change.*/
   template <class Scalar,class LocalOrdinal, class GlobalOrdinal, class Node>
-  void LineDetectionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::sort_coordinates(LO numCoords, LO* OrigLoc, Scalar* xvals, Scalar* yvals, Scalar* zvals, Scalar* xtemp, Scalar* ytemp, Scalar* ztemp, bool flipXY) const {
+  void LineDetectionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::sort_coordinates(LO numCoords, LO* OrigLoc,
+                                                                                         typename Teuchos::ScalarTraits<Scalar>::coordinateType* xvals,
+                                                                                         typename Teuchos::ScalarTraits<Scalar>::coordinateType* yvals,
+                                                                                         typename Teuchos::ScalarTraits<Scalar>::coordinateType* zvals,
+                                                                                         typename Teuchos::ScalarTraits<Scalar>::coordinateType* xtemp,
+                                                                                         typename Teuchos::ScalarTraits<Scalar>::coordinateType* ytemp,
+                                                                                         typename Teuchos::ScalarTraits<Scalar>::coordinateType* ztemp,
+                                                                                         bool flipXY) const {
 
     if( flipXY == false ) { // for line-smoothing
       for (LO i = 0; i < numCoords; i++) xtemp[i]= xvals[i];
@@ -376,7 +383,7 @@ namespace MueLu {
     LO index = 0;
 
     while ( index < numCoords ) {
-      SC xfirst = xtemp[index];
+      coordinate_type xfirst = xtemp[index];
       LO next   = index+1;
       while ( (next != numCoords) && (xtemp[next] == xfirst))
         next++;
@@ -385,7 +392,7 @@ namespace MueLu {
       /* One final sort so that the ztemps are in order */
       LO subindex = index;
       while (subindex != next) {
-        SC yfirst = ytemp[subindex];
+        coordinate_type yfirst = ytemp[subindex];
         LO subnext = subindex+1;
         while ( (subnext != next) && (ytemp[subnext] == yfirst)) subnext++;
         ML_az_dsort2(&(ztemp[subindex]),subnext-subindex,&(OrigLoc[subindex]));
@@ -398,10 +405,10 @@ namespace MueLu {
 
   /* Sort coordinates and additional array accordingly (if provided). This is an expert routine borrowed from ML. Do not change.*/
   template <class Scalar,class LocalOrdinal, class GlobalOrdinal, class Node>
-  void LineDetectionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::ML_az_dsort2(Scalar dlist[], LocalOrdinal N, LocalOrdinal list2[]) const {
+  void LineDetectionFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::ML_az_dsort2(typename Teuchos::ScalarTraits<Scalar>::coordinateType dlist[], LocalOrdinal N, LocalOrdinal list2[]) const {
     LO l, r, j, i, flag;
     LO RR2;
-    SC       dRR, dK;
+    coordinate_type       dRR, dK;
 
     // note: we use that routine for sorting coordinates only. No complex coordinates are assumed...
     typedef Teuchos::ScalarTraits<SC> STS;

packages/muelu/src/Misc/MueLu_RAPShiftFactory_def.hpp

@@ -181,7 +181,7 @@ namespace MueLu {
       }
 
       Teuchos::ArrayView<const double> doubleShifts;
-      Teuchos::Array<double> myshifts;
+      Teuchos::ArrayRCP<double> myshifts;
       if(pL.isParameter("rap: shift array") && pL.get<Teuchos::Array<double> >("rap: shift array").size() > 0 ) {
         // Do we have an array of shifts?  If so, we set doubleShifts_
         doubleShifts = pL.get<Teuchos::Array<double> >("rap: shift array")();
@@ -225,7 +225,7 @@ namespace MueLu {
           Set(coarseLevel,"cfl-based shift array",myshifts);
         }
         else {
-          Teuchos::Array<double> myshifs = Get<Teuchos::Array<double> > (fineLevel,"cfl-based shift array");
+          myshifts = Get<Teuchos::ArrayRCP<double> > (fineLevel,"cfl-based shift array");
           doubleShifts = myshifts();
           Set(coarseLevel,"cfl-based shift array",myshifts);
           // NOTE: If we're not on level zero, then we should have a shift array

packages/stokhos/src/CMakeLists.txt

@@ -808,20 +808,22 @@ IF (Stokhos_ENABLE_Sacado)
       IF(TpetraCore_ENABLE_EXPLICIT_INSTANTIATION)
         PROCESS_ENSEMBLE_ETI(
           "${Stokhos_ETI_Ensemble_Sizes}"
-          "${TPETRA_ETI_CLASSES}"
+          "${TPETRA_SD_ETI_CLASSES}"
           "sacado/kokkos/vector/tpetra"
-          "Tpetra"
+          "Tpetra_SD"
           TRUE
           "${STOKHOS_DEPLIBS}"
           DEPLIBS_OUT)
         LIST(APPEND STOKHOS_TPETRA_DEPLIBS ${DEPLIBS_OUT})
-       PROCESS_ENSEMBLE_ETI(
+        # Tpetra depends on Tpetra_SD
+        SET(STOKHOS_TPETRA_DEPS ${STOKHOS_DEPLIBS} ${STOKHOS_TPETRA_DEPLIBS})
+        PROCESS_ENSEMBLE_ETI(
           "${Stokhos_ETI_Ensemble_Sizes}"
-          "${TPETRA_SD_ETI_CLASSES}"
+          "${TPETRA_ETI_CLASSES}"
           "sacado/kokkos/vector/tpetra"
-          "Tpetra_SD"
+          "Tpetra"
           TRUE
-          "${STOKHOS_DEPLIBS}"
+          "${STOKHOS_TPETRA_DEPS}"
           DEPLIBS_OUT)
         LIST(APPEND STOKHOS_TPETRA_DEPLIBS ${DEPLIBS_OUT})
         # TpetraExt depends on Tpetra
@@ -847,21 +849,23 @@ IF (Stokhos_ENABLE_Sacado)
           CrsMatrix
           )
         PROCESS_PCE_ETI(
-          "${TPETRA_ETI_CLASSES}"
-          "${EXTRA_TPETRA_ETI_CLASSES}"
+          "${TPETRA_SD_ETI_CLASSES}"
+          ""
           "sacado/kokkos/pce/tpetra"
-          "Tpetra"
+          "Tpetra_SD"
           TRUE
           "${STOKHOS_DEPLIBS}"
           DEPLIBS_OUT)
         LIST(APPEND STOKHOS_TPETRA_DEPLIBS ${DEPLIBS_OUT})
+        # Tpetra depends on Tpetra_SD
+        SET(STOKHOS_TPETRA_DEPS ${STOKHOS_DEPLIBS} ${STOKHOS_TPETRA_DEPLIBS})
         PROCESS_PCE_ETI(
-          "${TPETRA_SD_ETI_CLASSES}"
-          ""
+          "${TPETRA_ETI_CLASSES}"
+          "${EXTRA_TPETRA_ETI_CLASSES}"
           "sacado/kokkos/pce/tpetra"
-          "Tpetra_SD"
+          "Tpetra"
           TRUE
-          "${STOKHOS_DEPLIBS}"
+          "${STOKHOS_TPETRA_DEPS}"
           DEPLIBS_OUT)
         LIST(APPEND STOKHOS_TPETRA_DEPLIBS ${DEPLIBS_OUT})
         # TpetraExt depends on Tpetra

packages/teuchos/parameterlist/src/Teuchos_ParameterList.hpp

@@ -1024,9 +1024,9 @@ void ParameterList::recursivelySetValidator(
     if (this->isSublist(entry_name) && depth > 0){
       this->sublist(entry_name).recursivelySetValidator<T>(validator, depth - 1);
     } else{
-      ParameterEntry *entry = this->getEntryPtr(entry_name);
-      if (entry->isType<T>()){
-        entry->setValidator(validator);
+      ParameterEntry *theEntry = this->getEntryPtr(entry_name);
+      if (theEntry->isType<T>()){
+        theEntry->setValidator(validator);
       }
     }
   }