DEME 2.2.0__tar.gz → 2.3.0__tar.gz

{deme-2.2.0/deme.egg-info → deme-2.3.0}/PKG-INFO

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

{deme-2.2.0 → deme-2.3.0/deme.egg-info}/PKG-INFO

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

{deme-2.2.0 → deme-2.3.0}/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.2.0",
+    version="2.3.0",
     author="Ruochun Zhang",
     author_email="ruochunz@gmail.com",
     description="PyBind Wrapper Library for DEM-Engine",

{deme-2.2.0 → deme-2.3.0}/src/DEM/PyDEME.cpp

@@ -1250,6 +1250,13 @@ 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.2.0 → deme-2.3.0}/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.2.0 → deme-2.3.0}/src/core/utils/JitHelper.cpp

@@ -16,7 +16,7 @@
 #include "RuntimeData.h"
 #include "JitHelper.h"
 
-jitify::JitCache JitHelper::kcache;
+jitify::JitCache* JitHelper::kcache = nullptr;
 
 // const std::filesystem::path JitHelper::KERNEL_DIR = DEMERuntimeDataHelper::data_path / "kernel";
 // const std::filesystem::path JitHelper::KERNEL_INCLUDE_DIR = DEMERuntimeDataHelper::include_path;
@@ -84,5 +84,8 @@ jitify::Program JitHelper::buildProgram(
     }
     */
 
-    return kcache.program(code, header_code, flags);
+    if (kcache == nullptr)
+        kcache = new jitify::JitCache();
+
+    return kcache->program(code, header_code, flags);
 }

{deme-2.2.0 → deme-2.3.0}/src/core/utils/JitHelper.h

@@ -48,7 +48,7 @@ class JitHelper {
     static std::filesystem::path KERNEL_INCLUDE_DIR;
 
   private:
-    static jitify::JitCache kcache;
+    static jitify::JitCache* kcache;
 
     inline static std::string loadSourceFile(const std::filesystem::path& sourcefile) {
         std::string code;

{deme-2.2.0 → deme-2.3.0}/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: