DEME 2.1.9__tar.gz → 2.2.1__tar.gz

{deme-2.1.9/deme.egg-info → deme-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deme
-Version: 2.1.9
+Version: 2.2.1
 Summary: PyBind Wrapper Library for DEM-Engine
 Author: Ruochun Zhang
 Author-email: ruochunz@gmail.com

{deme-2.1.9 → deme-2.2.1}/README.md

@@ -177,6 +177,7 @@ After the build process is done, you can start trying out the demos. On Windows,
 
 Some additional troubleshooting tips for running the demos:
 
+- If the program silently exits while creating the `DEMSolver` object, check if your NVIDIA driver supports your current CUDA version (`nvidia-smi`).
 - If errors similar to `CUDA_ERROR_UNSUPPORTED_PTX_VERSION` are encountered while you run the demos, or (rarely) the simulations proceed without detecting any contacts, then please make sure the CUDA installation is the same version as when the code is compiled.
 - Another cause for the simulations proceeding without detecting any contacts, could be the force kernel silently failed. This could also lead to a **too-many-geometries-in-bin** crash. The cause is usually that the force kernel was launched with too many threads per block, therefore not enough registers can be leveraged. This can be avoided by calling `SetForceCalcThreadsPerBlock` prior to the start of simulation with the argument being smaller choices like 128. **Note that you should only try this if you are using a custom force model**.
 - Used your own force model but got runtime compilation error like `expression must have pointer-to-object type but it has type "float"`, or `unknown variable "delta_time"`? Check out what we did in demo `DEMdemo_Electrostatic`. You may need to manually specify what material properties are pairwise and what contact wildcards you have using `SetMustPairwiseMatProp` and `SetPerContactWildcards`.

{deme-2.1.9 → deme-2.2.1}/cmake/CudaSupportedArchitectures.cmake

@@ -20,7 +20,6 @@
 # version of the CUDA Toolkit
 #
 # Minimum CUDA version: 7.0
-# Maximum CUDA version: 11.6
 
 function(cuda_supported_architectures)
 
@@ -31,7 +30,9 @@ function(cuda_supported_architectures)
 	set(cu10 30 35 50 52 60 61 70 72 75)
 	set(cu11 35 50 52 60 61 70 72 75 80)
 	set(cu11_x 35 50 52 60 61 70 72 75 80 86)
-	set(cu12_x 50 52 60 61 70 72 75 80 86)
+	set(cu12_x 50 52 60 61 70 72 75 80 86 89)
+	set(cu12_8 50 52 60 61 70 72 75 80 86 89 120)
+	set(cu13_x 75 80 86 89 90 100 120 121)
 
 	if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 7)
 		set(CUDASUP_ARCHITECTURES ${cu7} CACHE INTERNAL "")
@@ -61,6 +62,14 @@ function(cuda_supported_architectures)
 		set(CUDASUP_ARCHITECTURES ${cu12_x} CACHE INTERNAL "")
 	endif()
 
+	if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 12.8)
+		set(CUDASUP_ARCHITECTURES ${cu12_8} CACHE INTERNAL "")
+	endif()
+	
+    if (CMAKE_CUDA_COMPILER_VERSION VERSION_GREATER_EQUAL 13)
+        set(CUDASUP_ARCHITECTURES ${cu13_x} CACHE INTERNAL "")
+    endif()
+
 	if (NOT DEFINED CUDASUP_ARCHITECTURES)
 		message(SEND_ERROR "[CUDASUP] Could not determine device architectures supported by the CUDA toolkit!")
 	endif()

{deme-2.1.9 → deme-2.2.1/deme.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deme
-Version: 2.1.9
+Version: 2.2.1
 Summary: PyBind Wrapper Library for DEM-Engine
 Author: Ruochun Zhang
 Author-email: ruochunz@gmail.com

{deme-2.1.9 → deme-2.2.1}/setup.py

@@ -152,7 +152,7 @@ class CMakeBuild(build_ext):
 # logic and declaration, and simpler if you include description/version in a file.
 setup(
     name="deme",
-    version="2.1.9",
+    version="2.2.1",
     author="Ruochun Zhang",
     author_email="ruochunz@gmail.com",
     description="PyBind Wrapper Library for DEM-Engine",

{deme-2.1.9 → deme-2.2.1}/src/DEM/APIPrivate.cpp

@@ -2138,8 +2138,12 @@ inline void DEMSolver::equipKernelIncludes(std::unordered_map<std::string, std::
 // It's put here as ApiVersion.h.in (which sets DEME_CUDA_TOOLKIT_HEADERS) is a CMake-in configuration file, we don't
 // want to include it anywhere in the h headers in case DEM-Engine is included by some parent project.
 void DEMSolver::setDefaultSolverParams() {
-    m_jitify_options = {"-I" + (JitHelper::KERNEL_INCLUDE_DIR).string(), "-I" + (JitHelper::KERNEL_DIR).string(),
-                        "-I" + std::string(DEME_CUDA_TOOLKIT_HEADERS), "-diag-suppress=550", "-diag-suppress=177"};
+    m_jitify_options = {"-I" + (JitHelper::KERNEL_INCLUDE_DIR).string(),
+                        "-I" + (JitHelper::KERNEL_DIR).string(),
+                        "-I" + std::string(DEME_CUDA_TOOLKIT_HEADERS),
+                        "-std=c++17",
+                        "-diag-suppress=550",
+                        "-diag-suppress=177"};
 }
 
 }  // namespace deme

{deme-2.1.9 → deme-2.2.1}/src/DEM/HostSideHelpers.hpp

@@ -588,7 +588,7 @@ inline std::vector<double> FrameTransformLocalToGlobal(const std::vector<double>
                                                        const std::vector<double>& vec,
                                                        const std::vector<double>& rot_Q) {
     double3 deme_pos, deme_vec;
-    double4 deme_Q;
+    double4_vec deme_Q;
     deme_pos.x = pos[0];
     deme_pos.y = pos[1];
     deme_pos.z = pos[2];
@@ -599,7 +599,7 @@ inline std::vector<double> FrameTransformLocalToGlobal(const std::vector<double>
     deme_Q.y = rot_Q[1];
     deme_Q.z = rot_Q[2];
     deme_Q.w = rot_Q[3];
-    applyFrameTransformLocalToGlobal<double3, double3, double4>(deme_pos, deme_vec, deme_Q);
+    applyFrameTransformLocalToGlobal<double3, double3, double4_vec>(deme_pos, deme_vec, deme_Q);
     return {deme_pos.x, deme_pos.y, deme_pos.z};
 }
 
@@ -618,7 +618,7 @@ inline std::vector<double> FrameTransformGlobalToLocal(const std::vector<double>
                                                        const std::vector<double>& vec,
                                                        const std::vector<double>& rot_Q) {
     double3 deme_pos, deme_vec;
-    double4 deme_Q;
+    double4_vec deme_Q;
     deme_pos.x = pos[0];
     deme_pos.y = pos[1];
     deme_pos.z = pos[2];
@@ -629,7 +629,7 @@ inline std::vector<double> FrameTransformGlobalToLocal(const std::vector<double>
     deme_Q.y = rot_Q[1];
     deme_Q.z = rot_Q[2];
     deme_Q.w = rot_Q[3];
-    applyFrameTransformGlobalToLocal<double3, double3, double4>(deme_pos, deme_vec, deme_Q);
+    applyFrameTransformGlobalToLocal<double3, double3, double4_vec>(deme_pos, deme_vec, deme_Q);
     return {deme_pos.x, deme_pos.y, deme_pos.z};
 }
 

{deme-2.1.9 → deme-2.2.1}/src/DEM/PyDEME.cpp

@@ -1250,6 +1250,14 @@ PYBIND11_MODULE(DEME, obj) {
                  &deme::DEMClumpBatch::AddGeometryWildcard))
         .def("AddGeometryWildcard", static_cast<void (deme::DEMClumpBatch::*)(const std::string&, float)>(
                                         &deme::DEMClumpBatch::AddGeometryWildcard))
+        .def("SetOriQ",
+              static_cast<void (deme::DEMClumpBatch::*)(const std::vector<float4>&)>(&deme::DEMClumpBatch::SetOriQ))
+        .def("SetOriQ",
+             static_cast<void (deme::DEMClumpBatch::*)(float4)>(&deme::DEMClumpBatch::SetOriQ))
+        .def("SetOriQ",
+              static_cast<void (deme::DEMClumpBatch::*)(const std::vector<float>&)>(&deme::DEMClumpBatch::SetOriQ))
+        .def("SetOriQ", static_cast<void (deme::DEMClumpBatch::*)(const std::vector<std::vector<float>>&)>(
+                            &deme::DEMClumpBatch::SetOriQ))
         .def("GetNumContacts", &deme::DEMClumpBatch::GetNumContacts);
 
     py::class_<deme::DEMExternObj, deme::DEMInitializer, std::shared_ptr<deme::DEMExternObj>>(obj, "DEMExternObj")

{deme-2.1.9 → deme-2.2.1}/src/DEM/kT.cpp

@@ -83,14 +83,13 @@ void DEMKinematicThread::calibrateParams() {
             } else {
                 simParams->binSize /= (1. - stateParams.binCurrentChangeRate);
             }
-            // Register the new bin size
-            stateParams.numBins =
-                hostCalcBinNum(simParams->nbX, simParams->nbY, simParams->nbZ, simParams->voxelSize, simParams->binSize,
-                               simParams->nvXp2, simParams->nvYp2, simParams->nvZp2);
-
-            DEME_DEBUG_PRINTF("Bin size is now: %.7g", simParams->binSize);
-            DEME_DEBUG_PRINTF("Total num of bins is now: %zu", stateParams.numBins);
         }
+        // Register the new bin size
+        stateParams.numBins = hostCalcBinNum(simParams->nbX, simParams->nbY, simParams->nbZ, simParams->voxelSize,
+                                             simParams->binSize, simParams->nvXp2, simParams->nvYp2, simParams->nvZp2);
+
+        DEME_DEBUG_PRINTF("Bin size is now: %.7g", simParams->binSize);
+        DEME_DEBUG_PRINTF("Total num of bins is now: %zu", stateParams.numBins);
         DEME_DEBUG_PRINTF("kT runtime per step: %.7gs", CDAccumTimer.GetPrevTime());
     }
     // binSize is now calculated, we need to migrate that to device

{deme-2.1.9 → deme-2.2.1}/src/algorithms/DEMCubWrappers.cu

@@ -8,6 +8,14 @@
 #include <DEM/Structs.h>
 #include <core/utils/GpuError.h>
 
+#if CUDART_VERSION >= 13000
+    #define DEME_CUB_SUM_OP(T) \
+        cuda::std::plus<T> {}
+#else
+    #define DEME_CUB_SUM_OP(T) \
+        cub::Sum {}
+#endif
+
 namespace deme {
 
 // Functor type for selecting values less than some criteria
@@ -75,10 +83,11 @@ inline void cubDEMPrefixScan(T1* d_in,
     // let you know when it happens. I made a trick: use ExclusiveScan and (T2)0 as the initial value, and this forces
     // cub to store results as T2 type.
     size_t cub_scratch_bytes = 0;
-    cub::DeviceScan::ExclusiveScan(NULL, cub_scratch_bytes, d_in, d_out, cub::Sum(), (T2)0, n, this_stream);
+    cub::DeviceScan::ExclusiveScan(NULL, cub_scratch_bytes, d_in, d_out, DEME_CUB_SUM_OP(T2), (T2)0, n, this_stream);
     DEME_GPU_CALL(cudaStreamSynchronize(this_stream));
     void* d_scratch_space = (void*)scratchPad.allocateScratchSpace(cub_scratch_bytes);
-    cub::DeviceScan::ExclusiveScan(d_scratch_space, cub_scratch_bytes, d_in, d_out, cub::Sum(), (T2)0, n, this_stream);
+    cub::DeviceScan::ExclusiveScan(d_scratch_space, cub_scratch_bytes, d_in, d_out, DEME_CUB_SUM_OP(T2), (T2)0, n,
+                                   this_stream);
     DEME_GPU_CALL(cudaStreamSynchronize(this_stream));
 }
 
@@ -156,23 +165,14 @@ inline void cubDEMReduceByKeys(T1* d_keys_in,
 template <typename T1, typename T2>
 void cubDEMSum(T1* d_in, T2* d_out, size_t n, cudaStream_t& this_stream, DEMSolverScratchData& scratchPad) {
     size_t cub_scratch_bytes = 0;
-    cub::DeviceReduce::Reduce(NULL, cub_scratch_bytes, d_in, d_out, n, cub::Sum(), (T2)0, this_stream);
+    cub::DeviceReduce::Reduce(NULL, cub_scratch_bytes, d_in, d_out, n, DEME_CUB_SUM_OP(T2), (T2)0, this_stream);
     DEME_GPU_CALL(cudaStreamSynchronize(this_stream));
     void* d_scratch_space = (void*)scratchPad.allocateScratchSpace(cub_scratch_bytes);
-    cub::DeviceReduce::Reduce(d_scratch_space, cub_scratch_bytes, d_in, d_out, n, cub::Sum(), (T2)0, this_stream);
+    cub::DeviceReduce::Reduce(d_scratch_space, cub_scratch_bytes, d_in, d_out, n, DEME_CUB_SUM_OP(T2), (T2)0,
+                              this_stream);
     DEME_GPU_CALL(cudaStreamSynchronize(this_stream));
 }
 
-// template <typename T1>
-// void cubDEMSum(T1* d_in, T1* d_out, size_t n, cudaStream_t& this_stream, DEMSolverScratchData& scratchPad) {
-//     size_t cub_scratch_bytes = 0;
-//     cub::DeviceReduce::Sum(NULL, cub_scratch_bytes, d_in, d_out, n, this_stream);
-//     DEME_GPU_CALL(cudaStreamSynchronize(this_stream));
-//     void* d_scratch_space = (void*)scratchPad.allocateScratchSpace(cub_scratch_bytes);
-//     cub::DeviceReduce::Sum(d_scratch_space, cub_scratch_bytes, d_in, d_out, n, this_stream);
-//     DEME_GPU_CALL(cudaStreamSynchronize(this_stream));
-// }
-
 template <typename T1>
 void cubDEMMax(T1* d_in, T1* d_out, size_t n, cudaStream_t& this_stream, DEMSolverScratchData& scratchPad) {
     size_t cub_scratch_bytes = 0;

{deme-2.1.9 → deme-2.2.1}/src/core/utils/JitHelper.cpp

@@ -7,6 +7,10 @@
 #include <filesystem>
 #include <string>
 #include <regex>
+#include <vector>
+#include <sstream>
+#include <algorithm>
+#include <cstdlib>
 
 #include <core/ApiVersion.h>
 #include "RuntimeData.h"
@@ -41,6 +45,29 @@ jitify::Program JitHelper::buildProgram(
     std::unordered_map<std::string, std::string> substitutions,
     // std::vector<JitHelper::Header> headers, // THIS PARAMETER PROBABLY WON'T EVER BE USED
     std::vector<std::string> flags) {
+    // Double ensure include paths for runtime headers + CUDA/CCCL (cuda::std)
+    auto add_inc = [&](const std::filesystem::path& p) {
+        if (p.empty())
+            return;
+        std::error_code ec;
+        if (!std::filesystem::exists(p, ec))
+            return;
+        const std::string inc_flag = "-I" + p.string();
+        if (std::find(flags.begin(), flags.end(), inc_flag) == flags.end())
+            flags.push_back(inc_flag);
+    };
+
+    // Project/runtime includes
+    add_inc(KERNEL_INCLUDE_DIR);
+
+    // Common fallbacks
+    if (const char* cuda_home = std::getenv("CUDA_HOME")) {
+        add_inc(std::filesystem::path(cuda_home) / "include");
+        add_inc(std::filesystem::path(cuda_home) / "include" / "cccl");
+    }
+    add_inc("/usr/local/cuda/include");
+    add_inc("/usr/local/cuda/include/cccl");
+
     std::string code = name + "\n";
 
     code.append(JitHelper::loadSourceFile(source));

{deme-2.1.9 → deme-2.2.1}/src/core/utils/ManagedMemory.hpp

@@ -13,10 +13,27 @@
 // Convenience functions to help with Managed Memory (allocated using ManagedAllocator, typically)
 namespace deme {
 
+#if CUDART_VERSION >= 13000
+inline cudaMemLocation make_device_location(int device) {
+    cudaMemLocation loc{};
+    loc.type = cudaMemLocationTypeDevice;
+    loc.id = device;
+    return loc;
+}
+#endif
+
 // Underlying implementation
 template <class T>
 inline void __migrate_impl(T* data, std::size_t size, int device, cudaStream_t stream = 0) {
+#if CUDART_VERSION >= 13000
+    // CUDA 13.0+: cudaMemPrefetchAsync(const void*, size_t, cudaMemLocation, unsigned int flags, cudaStream_t)
+    auto loc = make_device_location(device);
+    unsigned int flags = 0;
+    cudaMemPrefetchAsync(static_cast<void*>(data), size * sizeof(T), loc, flags, stream);
+#else
+    // CUDA <= 12.x: cudaMemPrefetchAsync(const void*, size_t, int dstDevice, cudaStream_t)
     cudaMemPrefetchAsync(static_cast<void*>(data), size * sizeof(T), device, stream);
+#endif
 }
 
 // Pointer syntax, basically the same as cudaMemPrefetchAsync(...)
@@ -68,7 +85,16 @@ enum class ManagedAdvice {
 // Underlying implementation
 template <class T>
 void __advise_impl(const T* data, std::size_t size, ManagedAdvice advice, int device) {
-    cudaMemAdvise(data, size * sizeof(T), (cudaMemoryAdvise)advice, device);
+#if CUDART_VERSION >= 13000
+    cudaMemLocation loc{};
+    loc.type = cudaMemLocationTypeDevice;
+    loc.id = device;
+    // CUDA 13.0+: cudaMemAdvise(const void*, size_t, cudaMemoryAdvise, cudaMemLocation)
+    cudaMemAdvise(static_cast<const void*>(data), size * sizeof(T), static_cast<cudaMemoryAdvise>(advice), loc);
+#else
+    // Older toolkits: cudaMemAdvise(const void*, size_t, cudaMemoryAdvise, int)
+    cudaMemAdvise(static_cast<const void*>(data), size * sizeof(T), static_cast<cudaMemoryAdvise>(advice), device);
+#endif
 }
 
 // Advice for raw pointer

{deme-2.1.9 → deme-2.2.1}/src/kernel/CUDAMathHelpers.cuh

@@ -69,6 +69,17 @@ inline float rsqrtf(float x) {
 }
 #endif
 
+#if defined(CUDART_VERSION) && CUDART_VERSION >= 13000
+///////////////////////////////////////////////////
+// New Toolkits
+using double4_vec = double4_16a;  // or  double4_32a, but 32 byte alignment is not good for GPUs before Blackwell
+                                  // (128bit  --> 256 bit register)
+#else
+////////////////////////////////////////////////////
+// Old Toolkits
+using double4_vec = double4;
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 // constructors
 ////////////////////////////////////////////////////////////////////////////////
@@ -914,9 +925,12 @@ inline __host__ __device__ uint4 max(uint4 a, uint4 b) {
 // logical
 ////////////////////////////////////////////////////////////////////////////////
 
-inline __host__ __device__ bool floatNear(const float& a, const float& b, float tol = 1e-6f) {
+inline __host__ __device__ bool float_near(const float& a, const float& b, float tol = 1e-6f) {
     return fabs(a - b) < tol;
 }
+inline __host__ __device__ bool float3_near(const float3& a, const float3& b, float tol = 1e-6f) {
+    return float_near(a.x, b.x, tol) && float_near(a.y, b.y, tol) && float_near(a.z, b.z, tol);
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // lerp
@@ -1055,6 +1069,15 @@ inline __host__ __device__ float length(float3 v) {
 inline __host__ __device__ float length(float4 v) {
     return sqrtf(dot(v, v));
 }
+inline __host__ __device__ float length2(float2 v) {
+    return dot(v, v);
+}
+inline __host__ __device__ float length2(float3 v) {
+    return dot(v, v);
+}
+inline __host__ __device__ float length2(float4 v) {
+    return dot(v, v);
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 // normalize
@@ -1199,19 +1222,25 @@ inline __host__ __device__ float dot(double3 a, float3 b) {
     return a.x * b.x + a.y * b.y + a.z * b.z;
 }
 
-inline __host__ __device__ double dot(double4 a, double4 b) {
+inline __host__ __device__ double dot(double4_vec a, double4_vec b) {
     return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
 }
-inline __host__ __device__ float dot(double4 a, float4 b) {
+inline __host__ __device__ float dot(double4_vec a, float4 b) {
     return a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
 }
 
 inline __host__ __device__ double length(double3 v) {
     return sqrt(dot(v, v));
 }
-inline __host__ __device__ double length(double4 v) {
+inline __host__ __device__ double length(double4_vec v) {
     return sqrt(dot(v, v));
 }
+inline __host__ __device__ double length2(double3 v) {
+    return dot(v, v);
+}
+inline __host__ __device__ double length2(double4_vec v) {
+    return dot(v, v);
+}
 
 // Addition and subtraction
 
@@ -1343,14 +1372,27 @@ inline __host__ __device__ void operator/=(double3& a, double b) {
 inline __host__ __device__ float4 operator/(float4 a, double b) {
     return make_float4(a.x / b, a.y / b, a.z / b, a.w / b);
 }
-
+#if defined(CUDART_VERSION) && CUDART_VERSION >= 13000
+///////////////////////////////////////////////////
+// New Toolkits
+inline __host__ __device__ double4_vec operator/(double4_vec a, float b) {
+    return make_double4_16a(a.x / b, a.y / b, a.z / b, a.w / b);
+}
+inline __host__ __device__ double4_vec operator/(double4_vec a, double b) {
+    return make_double4_16a(a.x / b, a.y / b, a.z / b, a.w / b);
+}
+#else
+////////////////////////////////////////////////////
+// Old Toolkits
 inline __host__ __device__ double4 operator/(double4 a, float b) {
     return make_double4(a.x / b, a.y / b, a.z / b, a.w / b);
 }
 inline __host__ __device__ double4 operator/(double4 a, double b) {
     return make_double4(a.x / b, a.y / b, a.z / b, a.w / b);
 }
-inline __host__ __device__ void operator/=(double4& a, float b) {
+#endif
+
+inline __host__ __device__ void operator/=(double4_vec& a, float b) {
     a.x /= b;
     a.y /= b;
     a.z /= b;
@@ -1362,17 +1404,23 @@ inline __host__ __device__ double3 normalize(double3 v) {
     return v * invLen;
 }
 
+// Lexicographic comparator
+template <typename T>
+inline __host__ __device__ bool lex_less(T a, T b) {
+    if (a.x != b.x)
+        return a.x < b.x;
+    if (a.y != b.y)
+        return a.y < b.y;
+    return a.z < b.z;
+}
+
 // Float3 < is an element-wise comparison where x, y, z components are assigned priorities in that order.
 // Must be in global namespace for std::less to pick it up.
 inline __host__ __device__ bool operator<(const float3& a, const float3& b) {
-    if (floatNear(a.x, b.x))  // x component being different
-        return a.x < b.x;
-    else if (floatNear(a.y, b.y))  // x comp. same but y different
-        return a.y < b.y;
-    else if (floatNear(a.z, b.z))  // y comp. same but z different
-        return a.z < b.z;
-    else               // all components same
-        return false;  // for constructing a set
+    return lex_less(a, b);
+}
+inline __host__ __device__ bool operator<(const double3& a, const double3& b) {
+    return lex_less(a, b);
 }
 
 // Assignment

{deme-2.1.9 → deme-2.2.1}/src/kernel/DEMHelperKernels.cuh

@@ -454,58 +454,6 @@ inline __host__ __device__ void matProxy2ContactParam(T1& E_eff,
     E_eff = (T1)1 / invE;
 }
 
-/*
-// This version of checkSphereEntityOverlap is not used anymore for code clarity, and the fact that every use case now
-// requires overlapDepth.
-template <typename T1, typename T2>
-inline __device__ deme::contact_t checkSphereEntityOverlap(const T1& A,
-                                                           const T2& radA,
-                                                           const deme::objType_t& typeB,
-                                                           const T1& B,
-                                                           const float3& dirB,
-                                                           const float& size1B,
-                                                           const float& size2B,
-                                                           const float& size3B,
-                                                           const float& normal_sign,
-                                                           const float& beta4Entity) {
-    deme::contact_t contactType;
-    switch (typeB) {
-        case (deme::ANAL_OBJ_TYPE_PLANE): {
-            const T1 plane2sph = A - B;
-            // Plane is directional, and the direction is given by plane rotation
-            const double dist = dot(plane2sph, dirB);
-            const double overlapDepth = (radA + beta4Entity - dist);
-            if (overlapDepth < 0.0) {
-                contactType = deme::NOT_A_CONTACT;
-            } else {
-                contactType = deme::SPHERE_PLANE_CONTACT;
-            }
-            return contactType;
-        }
-        case (deme::ANAL_OBJ_TYPE_PLATE): {
-            return deme::NOT_A_CONTACT;
-        }
-        case (deme::ANAL_OBJ_TYPE_CYL_INF): {
-            T1 sph2cyl = B - A;
-            // Projection along cyl axis direction
-            const double proj_dist = dot(sph2cyl, dirB);
-            // Radial vector from cylinder center to sphere center, along inward direction
-            sph2cyl -= proj_dist * dirB;
-            const double dist_delta_r = length(sph2cyl);
-            const double overlapDepth = radA - abs(size1B - dist_delta_r - beta4Entity);
-            if (overlapDepth <= DEME_TINY_FLOAT) {
-                contactType = deme::NOT_A_CONTACT;
-            } else {
-                contactType = deme::SPHERE_CYL_CONTACT;
-            }
-            return contactType;
-        }
-        default:
-            return deme::NOT_A_CONTACT;
-    }
-}
-*/
-
 // Check whether a sphere and an analytical boundary are in contact, and gives overlap depth, contact point and contact
 // normal.
 template <typename T1, typename T2, typename T3>
@@ -550,15 +498,21 @@ inline __host__ __device__ deme::contact_t checkSphereEntityOverlap(const T1& A,
             // Radial vector from cylinder center to sphere center, along inward direction
             sph2cyl -= proj_dist * dirB;
             const T3 dist_delta_r = length(sph2cyl);
-            overlapDepth = radA - abs(size1B - dist_delta_r - beta4Entity);
-            if (overlapDepth <= DEME_TINY_FLOAT) {
+            // We can think the existence of beta4Entity simply enlarges or shrinks the rad of cyl
+            float cyl_rad = size1B - normal_sign * beta4Entity;
+            overlapDepth = radA - normal_sign * (cyl_rad - dist_delta_r);
+            if (overlapDepth < (T3)0.0) {
                 contactType = deme::NOT_A_CONTACT;
             } else {
                 contactType = deme::SPHERE_CYL_CONTACT;
             }
-            // dist_delta_r is 0 only when cylinder is thinner than sphere rad...
-            cntNormal = to_real3<T1, float3>(normal_sign / dist_delta_r * sph2cyl);
-            CP = A - to_real3<float3, T1>(cntNormal * (radA - overlapDepth / 2.0));
+            if (dist_delta_r >= (T3)DEME_TINY_FLOAT) {
+                cntNormal = to_real3<T1, float3>(normal_sign / dist_delta_r * sph2cyl);
+                CP = A - to_real3<float3, T1>(cntNormal * (radA - overlapDepth / 2.0));
+            } else {
+                cntNormal = dirB;
+                CP = A;
+            }
             return contactType;
         }
         default: