merged fix to oversized controller and changed Element to use baseType

Author: Kloepfer

.github/workflows/pr_comment_trigger_self_hosted.yml

@@ -50,7 +50,7 @@ jobs:
           echo "workDir $workDir"
 
           # kokkos
-          git clone -b develop git@github.com:kokkos/kokkos.git ${workDir}/kokkos
+          git clone -b develop https://github.com/kokkos/kokkos.git ${workDir}/kokkos
           kkbdir=${workDir}/build-kokkos
           cmake -S ${workDir}/kokkos -B $kkbdir \
             -DCMAKE_BUILD_TYPE=Release \
@@ -66,7 +66,7 @@ jobs:
           cmake --build $kkbdir --target install -j 4
 
           ##cabana
-          git clone git@github.com:ECP-copa/Cabana.git ${workDir}/cabana
+          git clone https://github.com/ECP-copa/Cabana.git ${workDir}/cabana
           cabbdir=${workDir}/build-cab
           cmake -S ${workDir}/cabana -B $cabbdir \
             -DCMAKE_BUILD_TYPE="Release" \
@@ -81,7 +81,7 @@ jobs:
           cmake --build $cabbdir -j 4 --target install
 
           # omegah
-          git clone git@github.com:SCOREC/omega_h.git ${workDir}/omegah
+          git clone https://github.com/SCOREC/omega_h.git ${workDir}/omegah
           ohbdir=${workDir}/build-omegah
           cmake -S ${workDir}/omegah -B $ohbdir \
             -DCMAKE_INSTALL_PREFIX=$ohbdir/install \

src/MeshField.hpp

@@ -32,15 +32,17 @@ MeshField::MeshInfo getMeshInfo(Omega_h::Mesh &mesh) {
   return meshInfo;
 }
 
-template <typename ExecutionSpace, template <typename...> typename Controller =
-                                       MeshField::KokkosController>
-decltype(MeshField::CreateCoordinateField<ExecutionSpace, Controller>(
+template <typename ExecutionSpace, size_t dim,
+          template <typename...>
+          typename Controller = MeshField::KokkosController>
+decltype(MeshField::CreateCoordinateField<ExecutionSpace, Controller, dim>(
     MeshField::MeshInfo()))
 createCoordinateField(const MeshField::MeshInfo &mesh_info,
                       Omega_h::Reals coords) {
   const auto meshDim = mesh_info.dim;
   auto coordField =
-      MeshField::CreateCoordinateField<ExecutionSpace, Controller>(mesh_info);
+      MeshField::CreateCoordinateField<ExecutionSpace, Controller, dim>(
+          mesh_info);
   auto setCoordField = KOKKOS_LAMBDA(const int &i) {
     coordField(i, 0, 0, MeshField::Vertex) = coords[i * meshDim];
     coordField(i, 0, 1, MeshField::Vertex) = coords[i * meshDim + 1];
@@ -167,23 +169,27 @@ template <int ShapeOrder> auto getTriangleElement(Omega_h::Mesh &mesh) {
 
 } // namespace Omegah
 
-template <typename ExecutionSpace, template <typename...> typename Controller =
-                                       MeshField::KokkosController>
+template <typename ExecutionSpace, size_t dim,
+          template <typename...> typename Controller =
+              MeshField::KokkosController>
 class OmegahMeshField {
 private:
   Omega_h::Mesh &mesh;
   const MeshField::MeshInfo meshInfo;
-  using CoordField = decltype(createCoordinateField<ExecutionSpace, Controller>(
-      MeshField::MeshInfo(), Omega_h::Reals()));
+  using CoordField =
+      decltype(createCoordinateField<ExecutionSpace, dim, Controller>(
+          MeshField::MeshInfo(), Omega_h::Reals()));
   CoordField coordField;
 
 public:
   OmegahMeshField(Omega_h::Mesh &mesh_in)
       : mesh(mesh_in), meshInfo(getMeshInfo(mesh)),
-        coordField(createCoordinateField<ExecutionSpace, Controller>(
-            getMeshInfo(mesh_in), mesh_in.coords())) {}
+        coordField(createCoordinateField<ExecutionSpace, dim, Controller>(
+            getMeshInfo(mesh_in), mesh_in.coords())) {
+    static_assert(dim == 1 || dim == 2 || dim == 3);
+  }
 
-  template <typename DataType, size_t order, size_t dim>
+  template <typename DataType, size_t order>
   // Ordering of field indexing changed to 'entity, node, component'
   auto CreateLagrangeField() {
     return MeshField::CreateLagrangeField<ExecutionSpace, Controller, DataType,

src/MeshField_Element.hpp

@@ -188,8 +188,9 @@ struct FieldElement {
     return c;
   }
 
-  using NodeArray = Kokkos::Array<typename FieldAccessor::BaseType,
-                                  ShapeType::meshEntDim * ShapeType::numNodes>;
+  using NodeArray =
+      Kokkos::Array<typename baseType<typename FieldAccessor::BaseType>::type,
+                    ShapeType::meshEntDim * ShapeType::numNodes>;
   KOKKOS_INLINE_FUNCTION NodeArray getNodeValues(int ent) const {
     NodeArray c;
     for (auto topo : elm2dof.getTopology()) { // element topology

src/MeshField_ShapeField.hpp

@@ -267,22 +267,23 @@ auto CreateLagrangeField(const MeshInfo &meshInfo) {
  * @return a linear ShapeField
  */
 
-template <typename ExecutionSpace, template <typename...> typename Controller =
-                                       MeshField::KokkosController>
+template <typename ExecutionSpace,
+          template <typename...>
+          typename Controller = MeshField::KokkosController,
+          size_t dim>
 auto CreateCoordinateField(const MeshInfo &meshInfo) {
   if (meshInfo.numVtx <= 0) {
     fail("mesh has no vertices\n");
   }
   using DataType = Real;
   using MemorySpace = typename ExecutionSpace::memory_space;
   const int numComp = meshInfo.dim;
-// FIXME Oversized cabana datatypes when numComp = 1|2, specialize controller template for dimension? //HERE
 #ifdef MESHFIELDS_ENABLE_CABANA
   using Ctrlr = std::conditional_t<
       std::is_same_v<
           Controller<ExecutionSpace, MemorySpace, DataType>,
           MeshField::CabanaController<ExecutionSpace, MemorySpace, DataType>>,
-      Controller<ExecutionSpace, MemorySpace, DataType[1][3]>,
+      Controller<ExecutionSpace, MemorySpace, DataType[1][dim]>,
       Controller<MemorySpace, ExecutionSpace, DataType ***>>;
   auto createController = [](const int numComp, auto numVtx) {
     if constexpr (std::is_same_v<

test/testCountIntegrator.cpp

@@ -59,7 +59,7 @@ class CountIntegrator : public MeshField::Integrator {
 
 template <template <typename...> typename Controller>
 void doRun(Omega_h::Mesh &mesh,
-           MeshField::OmegahMeshField<ExecutionSpace, Controller> &omf) {
+           MeshField::OmegahMeshField<ExecutionSpace, 2, Controller> &omf) {
   const auto ShapeOrder = 1;
   auto field = omf.getCoordField();
   const auto [shp, map] =
@@ -77,14 +77,14 @@ int main(int argc, char **argv) {
   auto mesh = createMeshTri18(lib);
 #ifdef MESHFIELDS_ENABLE_CABANA
   {
-    MeshField::OmegahMeshField<ExecutionSpace, MeshField::CabanaController> omf(
-        mesh);
+    MeshField::OmegahMeshField<ExecutionSpace, 2, MeshField::CabanaController>
+        omf(mesh);
     doRun<MeshField::CabanaController>(mesh, omf);
   }
 #endif
   {
-    MeshField::OmegahMeshField<ExecutionSpace, MeshField::KokkosController> omf(
-      mesh);
+    MeshField::OmegahMeshField<ExecutionSpace, 2, MeshField::KokkosController>
+        omf(mesh);
     doRun<MeshField::KokkosController>(mesh, omf);
   }
   return 0;

test/testElementJacobian1d.cpp

@@ -44,9 +44,8 @@ void setEdgeCoords(size_t numVerts, Kokkos::View<MeshField::Real *> coords,
 
 void edgeJacobian() {
   const MeshField::MeshInfo meshInfo{.numVtx = 2, .numEdge = 1, .dim = 1};
-  auto coordField =
-      MeshField::CreateCoordinateField<ExecutionSpace,
-                                       MeshField::KokkosController>(meshInfo);
+  auto coordField = MeshField::CreateCoordinateField<
+      ExecutionSpace, MeshField::KokkosController, 1>(meshInfo);
   Kokkos::View<MeshField::Real *, Kokkos::HostSpace> coords_h("coords_h", 2);
   coords_h[0] = -1;
   coords_h[1] = 1;

test/testElementJacobian2d.cpp

@@ -72,10 +72,8 @@ void setVtxCoords(size_t numVerts, size_t meshDim, TriangleTestCase testTri,
 void triJacobian() {
   const MeshField::MeshInfo meshInfo{
       .numVtx = 3, .numEdge = 3, .numTri = 1, .dim = 2};
-  auto coordField =
-      MeshField::CreateCoordinateField<ExecutionSpace,
-                                       MeshField::KokkosController>(meshInfo);
-
+  auto coordField = MeshField::CreateCoordinateField<
+      ExecutionSpace, MeshField::KokkosController, 2>(meshInfo);
   TriangleTestCase rightTriangle({0, 0, 1, 0, 0, 1}, {1, 0, 0, 1}, 1);
   TriangleTestCase skewedTriangle({0, 0, 5, 1, 3, 4}, {5, 1, 3, 4}, 17);
   for (auto testCase : {rightTriangle, skewedTriangle}) {

test/testOmegahElement.cpp

@@ -143,7 +143,7 @@ void doFail(std::string_view order, std::string_view function,
 
 template <template <typename...> typename Controller>
 void doRun(Omega_h::Mesh &mesh,
-           MeshField::OmegahMeshField<ExecutionSpace, Controller> &omf) {
+           MeshField::OmegahMeshField<ExecutionSpace, 2, Controller> &omf) {
 
   // setup field with values from the analytic function
   static const size_t OnePtPerElem = 1;
@@ -166,14 +166,14 @@ void doRun(Omega_h::Mesh &mesh,
   // clang-format on
 
   auto coords = mesh.coords();
-  const auto MeshDim = 2;
   for (auto testCase : cases) {
     using ViewType = decltype(testCase.coords);
     {
       const auto ShapeOrder = 1;
-      auto field = omf.template CreateLagrangeField<MeshField::Real, ShapeOrder,
-                                                    MeshDim>();
-      auto func = LinearFunction();
+
+      auto field =
+          omf.template CreateLagrangeField<MeshField::Real, ShapeOrder>();
+      LinearFunction func = LinearFunction();
       setVertices(mesh, func, field);
       using FieldType = decltype(field);
       auto result = omf.template triangleLocalPointEval<ViewType, FieldType>(
@@ -186,8 +186,8 @@ void doRun(Omega_h::Mesh &mesh,
 
     {
       const auto ShapeOrder = 2;
-      auto field = omf.template CreateLagrangeField<MeshField::Real, ShapeOrder,
-                                                    MeshDim>();
+      auto field =
+          omf.template CreateLagrangeField<MeshField::Real, ShapeOrder>();
       auto func = QuadraticFunction();
       setVertices(mesh, func, field);
       setEdges(mesh, func, field);
@@ -202,8 +202,8 @@ void doRun(Omega_h::Mesh &mesh,
 
     {
       const auto ShapeOrder = 2;
-      auto field = omf.template CreateLagrangeField<MeshField::Real, ShapeOrder,
-                                                    MeshDim>();
+      auto field =
+          omf.template CreateLagrangeField<MeshField::Real, ShapeOrder>();
       auto func = LinearFunction();
       setVertices(mesh, func, field);
       setEdges(mesh, func, field);
@@ -225,15 +225,15 @@ int main(int argc, char **argv) {
 #ifdef MESHFIELDS_ENABLE_CABANA
   {
     auto mesh = createMeshTri18(lib);
-    MeshField::OmegahMeshField<ExecutionSpace, MeshField::CabanaController> omf(
-        mesh);
+    MeshField::OmegahMeshField<ExecutionSpace, 2, MeshField::CabanaController>
+        omf(mesh);
     doRun<MeshField::CabanaController>(mesh, omf);
   }
 #endif
   {
     auto mesh = createMeshTri18(lib);
-    MeshField::OmegahMeshField<ExecutionSpace, MeshField::KokkosController> omf(
-        mesh);
+    MeshField::OmegahMeshField<ExecutionSpace, 2, MeshField::KokkosController>
+        omf(mesh);
     doRun<MeshField::KokkosController>(mesh, omf);
   }
   Kokkos::finalize();