Support Blueprint mesh in shaping

RELEASE-NOTES.md

@@ -20,6 +20,8 @@ The Axom project release numbers follow [Semantic Versioning](http://semver.org/
 ## [Unreleased] - Release date yyyy-mm-dd
 
 ###  Added
+- Support in `quest::IntersectionShaper` for Blueprint mesh stored in a `conduit::Node`
+  or `sidre::Group`.
 - A number of new `klee::Geometry` constructors are added, for the different shapes now supported.
   This is a temporary change.  The class will be subclassed in the future to support a diversity of geometries.
 - Support some analytical shapes in `IntersectionShaper`.
@@ -32,6 +34,8 @@ to use Open Cascade's file I/O capabilities in support of Quest applications.
 - Adds a Quest example that reads in a STEP file using Open Cascade and processes its geometry
 
 ###  Changed
+- `quest::Shaper` and `quest::IntersectionShaper` constructors require a runtime policy.
+  Changing the policy after construction is no longer supported.
 - Importing Conduit array data into `sidre::View` now allocates destination
   data using the `View`'s parent's allocator ID, instead of always using
   host memory.  This is consistent with the behavior of deep-copying data

src/axom/core/CMakeLists.txt

@@ -110,6 +110,7 @@ blt_list_append( TO core_depends ELEMENTS caliper IF CALIPER_FOUND )
 blt_list_append( TO core_depends ELEMENTS camp IF CAMP_FOUND )
 blt_list_append( TO core_depends ELEMENTS umpire IF UMPIRE_FOUND )
 blt_list_append( TO core_depends ELEMENTS RAJA IF RAJA_FOUND )
+blt_list_append( TO core_depends ELEMENTS conduit::conduit IF CONDUIT_FOUND )
 blt_list_append( TO core_depends ELEMENTS mpi IF AXOM_ENABLE_MPI )
 
 # HACK: RAJA's dependencies are not getting added to core due to a bug in

src/axom/core/Types.hpp

@@ -15,6 +15,10 @@
 // Axom includes
 #include "axom/config.hpp"
 
+#if defined(AXOM_USE_CONDUIT)
+  #include "conduit/conduit_data_type.hpp"
+#endif
+
 // C/C++ includes
 #include <cstdint>
 
@@ -62,8 +66,16 @@ using uint64 = std::uint64_t; /*!< 64-bit unsigned integer type   */
 
 #if defined(AXOM_USE_64BIT_INDEXTYPE) && !defined(AXOM_NO_INT64_T)
 using IndexType = std::int64_t;
+  #if defined(AXOM_USE_CONDUIT)
+static constexpr conduit::DataType::TypeID conduitDataIdOfAxomIndexType =
+  conduit::DataType::INT64_ID;
+  #endif
 #else
 using IndexType = std::int32_t;
+  #if defined(AXOM_USE_CONDUIT)
+static constexpr conduit::DataType::TypeID conduitDataIdOfAxomIndexType =
+  conduit::DataType::INT32_ID;
+  #endif
 #endif
 
 static constexpr IndexType InvalidIndex = -1;

src/axom/core/execution/execution_space.hpp

@@ -8,6 +8,7 @@
 
 #include "axom/config.hpp"
 #include "axom/core/memory_management.hpp"
+#include "axom/core/execution/runtime_policy.hpp"
 
 /*!
  * \file execution_space.hpp
@@ -88,6 +89,19 @@ struct execution_space
   static constexpr bool onDevice() noexcept { return false; }
   static constexpr char* name() noexcept { return (char*)"[UNDEFINED]"; }
   static int allocatorID() noexcept { return axom::INVALID_ALLOCATOR_ID; }
+  static constexpr runtime_policy::Policy runtimePolicy() noexcept
+  {
+    return runtime_policy::Policy::seq;
+  }
+  static bool usesMemorySpace(axom::MemorySpace m) noexcept
+  {
+    return m == memory_space;
+  }
+  static bool usesAllocId(int allocId) noexcept
+  {
+    return allocId == 0 ||
+      usesMemorySpace(axom::detail::getAllocatorSpace(allocId));
+  }
 };
 
 }  // namespace axom
@@ -109,4 +123,36 @@ struct execution_space
   #include "axom/core/execution/internal/hip_exec.hpp"
 #endif
 
+namespace axom
+{
+
+/// \brief Return default allocator id for a runtime policy.
+static const std::map<axom::runtime_policy::Policy, int> s_policyToDefaultAllocatorID {
+  {axom::runtime_policy::Policy::seq,
+   axom::execution_space<axom::SEQ_EXEC>::allocatorID()}
+#if defined(AXOM_RUNTIME_POLICY_USE_OPENMP)
+  ,
+  {axom::runtime_policy::Policy::omp,
+   axom::execution_space<axom::OMP_EXEC>::allocatorID()}
+#endif
+#if defined(AXOM_RUNTIME_POLICY_USE_CUDA)
+  ,
+  {axom::runtime_policy::Policy::cuda,
+   axom::execution_space<axom::CUDA_EXEC<256>>::allocatorID()}
+#endif
+#if defined(AXOM_RUNTIME_POLICY_USE_HIP)
+  ,
+  {axom::runtime_policy::Policy::hip,
+   axom::execution_space<axom::HIP_EXEC<256>>::allocatorID()}
+#endif
+};
+
+/// \brief Return default allocator id for a runtime policy.
+inline int policyToDefaultAllocatorID(axom::runtime_policy::Policy policy)
+{
+  return s_policyToDefaultAllocatorID.find(policy)->second;
+}
+
+}  // namespace axom
+
 #endif  // AXOM_EXECUTIONSPACE_HPP_

src/axom/core/execution/internal/cuda_exec.hpp

@@ -65,6 +65,19 @@ struct execution_space<CUDA_EXEC<BLOCK_SIZE, SYNCHRONOUS>>
   {
     return axom::getUmpireResourceAllocatorID(umpire::resource::Device);
   }
+  static constexpr runtime_policy::Policy runtimePolicy() noexcept
+  {
+    return runtime_policy::Policy::cuda;
+  }
+  static bool usesMemorySpace(axom::MemorySpace m) noexcept
+  {
+    return m == memory_space || m == MemorySpace::Unified;
+  }
+  static bool usesAllocId(int allocId) noexcept
+  {
+    return allocId == 0 ||
+      usesMemorySpace(axom::detail::getAllocatorSpace(allocId));
+  }
 };
 
 /*!
@@ -95,6 +108,19 @@ struct execution_space<CUDA_EXEC<BLOCK_SIZE, ASYNC>>
   {
     return axom::getUmpireResourceAllocatorID(umpire::resource::Device);
   }
+  static constexpr runtime_policy::Policy runtimePolicy() noexcept
+  {
+    return runtime_policy::Policy::cuda;
+  }
+  static bool usesMemorySpace(axom::MemorySpace m) noexcept
+  {
+    return m == memory_space || m == MemorySpace::Unified;
+  }
+  static bool usesAllocId(int allocId) noexcept
+  {
+    return allocId == 0 ||
+      usesMemorySpace(axom::detail::getAllocatorSpace(allocId));
+  }
 };
 }  // namespace axom
 

src/axom/core/execution/internal/hip_exec.hpp

@@ -63,6 +63,19 @@ struct execution_space<HIP_EXEC<BLOCK_SIZE, SYNCHRONOUS>>
   {
     return axom::getUmpireResourceAllocatorID(umpire::resource::Device);
   }
+  static constexpr runtime_policy::Policy runtimePolicy() noexcept
+  {
+    return runtime_policy::Policy::hip;
+  }
+  static bool usesMemorySpace(axom::MemorySpace m) noexcept
+  {
+    return m == memory_space || m == MemorySpace::Unified;
+  }
+  static bool usesAllocId(int allocId) noexcept
+  {
+    return allocId == 0 ||
+      usesMemorySpace(axom::detail::getAllocatorSpace(allocId));
+  }
 };
 
 /*!
@@ -90,6 +103,19 @@ struct execution_space<HIP_EXEC<BLOCK_SIZE, ASYNC>>
   {
     return axom::getUmpireResourceAllocatorID(umpire::resource::Device);
   }
+  static constexpr runtime_policy::Policy runtimePolicy() noexcept
+  {
+    return runtime_policy::Policy::hip;
+  }
+  static bool usesMemorySpace(axom::MemorySpace m) noexcept
+  {
+    return m == memory_space || m == MemorySpace::Unified;
+  }
+  static bool usesAllocId(int allocId) noexcept
+  {
+    return allocId == 0 ||
+      usesMemorySpace(axom::detail::getAllocatorSpace(allocId));
+  }
 };
 }  // namespace axom
 

src/axom/core/execution/internal/omp_exec.hpp

@@ -60,6 +60,23 @@ struct execution_space<OMP_EXEC>
     return axom::getDefaultAllocatorID();
 #endif
   }
+  static constexpr runtime_policy::Policy runtimePolicy() noexcept
+  {
+    return runtime_policy::Policy::omp;
+  }
+  static bool usesMemorySpace(axom::MemorySpace m) noexcept
+  {
+    return m == memory_space
+#ifdef AXOM_USE_UMPIRE
+      || m == MemorySpace::Unified
+#endif
+      ;
+  }
+  static bool usesAllocId(int allocId) noexcept
+  {
+    return allocId == 0 ||
+      usesMemorySpace(axom::detail::getAllocatorSpace(allocId));
+  }
 };
 
 }  // namespace axom

src/axom/core/execution/internal/seq_exec.hpp

@@ -69,6 +69,23 @@ struct execution_space<SEQ_EXEC>
     return axom::getDefaultAllocatorID();
 #endif
   }
+  static constexpr runtime_policy::Policy runtimePolicy() noexcept
+  {
+    return runtime_policy::Policy::seq;
+  }
+  static bool usesMemorySpace(axom::MemorySpace m) noexcept
+  {
+    return m == memory_space
+#ifdef AXOM_USE_UMPIRE
+      || m == MemorySpace::Unified
+#endif
+      ;
+  }
+  static bool usesAllocId(int allocId) noexcept
+  {
+    return allocId == 0 ||
+      usesMemorySpace(axom::detail::getAllocatorSpace(allocId));
+  }
 };
 
 }  // namespace axom

src/axom/core/execution/runtime_policy.hpp

@@ -6,7 +6,8 @@
 #ifndef AXOM_CORE_EXECUTION_RUNTIME_POLICY_HPP_
 #define AXOM_CORE_EXECUTION_RUNTIME_POLICY_HPP_
 
-#include "axom/config.hpp"   /* for compile time defs. */
+#include "axom/config.hpp" /* for compile time defs. */
+#include <string>
 #include "axom/fmt/format.h" /* for axom::fmt */
 
 #include <map>

src/axom/core/memory_management.hpp

@@ -110,6 +110,27 @@ inline int getDefaultAllocatorID()
 #endif
 }
 
+/*!
+ * \brief Get the allocator id from which data has been allocated.
+ * \return Allocator id.  If Umpire doesn't have an allocator for
+ * the pointer, or Axom wasn't configured with Umpire, return 0.
+ *
+ * \pre ptr has a valid pointer value.
+ */
+inline int getAllocatorIDFromPointer(const void* ptr)
+{
+#ifdef AXOM_USE_UMPIRE
+  umpire::ResourceManager& rm = umpire::ResourceManager::getInstance();
+  if(rm.hasAllocator(const_cast<void*>(ptr)))
+  {
+    umpire::Allocator allocator = rm.getAllocator(const_cast<void*>(ptr));
+    return allocator.getId();
+  }
+#endif
+  AXOM_UNUSED_VAR(ptr);
+  return 0;
+}
+
 /*!
  * \brief Allocates a chunk of memory of type T.
  *

src/axom/core/utilities/FileUtilities.cpp

@@ -106,6 +106,32 @@ int makeDirsForPath(const std::string& path)
   return err;
 }
 
+//-----------------------------------------------------------------------------
+std::string prefixRelativePath(const std::string& path, const std::string& prefix)
+{
+  if(path[0] == '/' || prefix.empty())
+  {
+    return path;
+  }
+  return utilities::filesystem::joinPath(prefix, path);
+}
+
+//-----------------------------------------------------------------------------
+std::string getParentPath(const std::string& path)
+{
+  char separator = '/';
+  std::size_t found = path.rfind(separator);
+
+  std::string parent;
+
+  if(found != std::string::npos)
+  {
+    parent = path.substr(0, found);
+  }
+
+  return parent;
+}
+
 //-----------------------------------------------------------------------------
 void getDirName(std::string& dir, const std::string& path)
 {

src/axom/core/utilities/FileUtilities.hpp

@@ -66,6 +66,28 @@ std::string joinPath(const std::string& fileDir,
  */
 int makeDirsForPath(const std::string& path);
 
+/*!
+ * \brief Add a prefix to a path if it is relative.
+ *
+ * \param [in] path string representing an absolute or relative path
+ * \param [in] prefix string representing a directory path
+ *
+ * \return \c prefix + \c path (with delimiter) if the path is
+ * relative or \c prefix is empty, or just \c path otherwise.
+ */
+std::string prefixRelativePath(const std::string& path,
+                               const std::string& prefix);
+
+/*!
+ * \brief Get parent path name from a filesystem path.
+ *
+ * \param [in] path an absolute or relative filesystem path
+ *
+ * \return a directory path formed by removing the last part of the
+ *    input path
+ */
+std::string getParentPath(const std::string& path);
+
 /*!
  * \brief Get directory name from a path that contains a file name
  *

src/axom/klee/Geometry.cpp

@@ -86,19 +86,19 @@ Geometry::Geometry(const TransformableGeometryProperties& startProperties,
 
 Geometry::Geometry(const TransformableGeometryProperties& startProperties,
                    const axom::Array<double, 2>& discreteFunction,
-                   const Point3D& vorBase,
-                   const Vector3D& vorDirection,
+                   const Point3D& sorBase,
+                   const Vector3D& sorDirection,
                    axom::IndexType levelOfRefinement,
                    std::shared_ptr<GeometryOperator const> operator_)
   : m_startProperties(startProperties)
-  , m_format("vor3D")
+  , m_format("sor3D")
   , m_path()
   , m_meshGroup(nullptr)
   , m_topology()
   , m_sphere()
   , m_discreteFunction(discreteFunction)
-  , m_vorBase(vorBase)
-  , m_vorDirection(vorDirection)
+  , m_sorBase(sorBase)
+  , m_sorDirection(sorDirection)
   , m_levelOfRefinement(levelOfRefinement)
   , m_operator(std::move(operator_))
 { }