2.3.0 rc Rebase 1 (#276)

* Update package versions (#270)

* Update to use the new tessellation API (#272)

* update versions

Author: ktangsali

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -31,7 +31,7 @@ body:
     attributes:
       label: Version
       description: What version of PhysicsNeMo and PhysicsNeMo Symbolic are you running?
-      placeholder: "example: 2.2.0"
+      placeholder: "example: 2.3.0"
     validations:
       required: true
 

CHANGELOG.md

@@ -6,12 +6,10 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [2.3.0a0] - 2025-XX-YY
+## [2.4.0a0] - 2026-XX-YY
 
 ### Added
 
-- Added Blackwell support
-
 ### Changed
 
 ### Deprecated
@@ -24,6 +22,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Dependencies
 
+## [2.3.0] - 2025-11-17
+
+### Added
+
+- Added Blackwell support
 
 ## [2.2.0] - 2025-08-26
 

physicsnemo/sym/__init__.py

@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-__version__ = "2.3.0a0"
+__version__ = "2.4.0a0"
 
 from pint import UnitRegistry
 

physicsnemo/sym/geometry/tessellation.py

@@ -19,14 +19,12 @@
 """
 
 import numpy as np
-import warp as wp
 from stl import mesh as np_mesh
 
 from .geometry import Geometry
 from .parameterization import Parameterization, Bounds, Parameter
 from .curve import Curve
 from physicsnemo.sym.constants import diff_str
-from physicsnemo.utils.sdf import signed_distance_field
 
 
 class Tessellation(Geometry):
@@ -118,47 +116,57 @@ def _sdf(triangles, airtight):
             def sdf(invar, params, compute_sdf_derivatives=False):
                 # gather points
                 points = np.stack([invar["x"], invar["y"], invar["z"]], axis=1)
+                points = np.squeeze(points)
+                if points.ndim == 1:
+                    points = points.reshape(1, -1)
 
                 # normalize triangles and points
                 minx, maxx, miny, maxy, minz, maxz = _find_mins_maxs(points)
                 max_dis = max(max((maxx - minx), (maxy - miny)), (maxz - minz))
-                store_triangles = np.array(triangles, dtype=np.float64)
+                store_triangles = np.array(triangles, dtype=np.float32)
                 store_triangles[:, :, 0] -= minx
                 store_triangles[:, :, 1] -= miny
                 store_triangles[:, :, 2] -= minz
                 store_triangles *= 1 / max_dis
-                store_triangles = store_triangles.reshape(-1, 3)
+                store_triangles = store_triangles.reshape(-1, 3)  # (n_vertices, 3)
                 points[:, 0] -= minx
                 points[:, 1] -= miny
                 points[:, 2] -= minz
                 points *= 1 / max_dis
-                points = points.astype(np.float64).flatten()
+                points = points.astype(np.float32)  # Keep as (n_points, 3)
 
                 # compute sdf values
                 outputs = {}
                 if airtight:
+                    # Import locally to avoid pickling issues with multiprocessing
+                    import torch
+                    from physicsnemo.utils.sdf import signed_distance_field
+
+                    torch_vertices = torch.from_numpy(store_triangles)
+                    torch_indices = torch.arange(
+                        store_triangles.shape[0], dtype=torch.int32
+                    )
+                    torch_points = torch.from_numpy(points)
+
                     sdf_field, sdf_derivative = signed_distance_field(
-                        store_triangles,
-                        np.arange((store_triangles.shape[0])),
-                        points,
-                        include_hit_points=True,
+                        torch_vertices,
+                        torch_indices,
+                        torch_points,
+                        max_dist=1e8,
+                        use_sign_winding_number=False,
                     )
-                    if isinstance(sdf_field, wp.types.array):
-                        sdf_field = sdf_field.numpy()
-                    if isinstance(sdf_derivative, wp.types.array):
-                        sdf_derivative = sdf_derivative.numpy()
+
+                    sdf_field = sdf_field.numpy()
+                    sdf_derivative = sdf_derivative.numpy()  # Shape: (n_points, 3)
+
                     sdf_field = -np.expand_dims(max_dis * sdf_field, axis=1)
-                    sdf_derivative = sdf_derivative.reshape(-1)
                 else:
                     sdf_field = np.zeros_like(invar["x"])
                 outputs["sdf"] = sdf_field
 
                 # get sdf derivatives
                 if compute_sdf_derivatives:
                     sdf_derivative = -(sdf_derivative - points)
-                    sdf_derivative = np.reshape(
-                        sdf_derivative, (sdf_derivative.shape[0] // 3, 3)
-                    )
                     sdf_derivative = sdf_derivative / np.linalg.norm(
                         sdf_derivative, axis=1, keepdims=True
                     )

physicsnemo/sym/geometry/tessellation_warp.py

@@ -24,7 +24,6 @@
 from .parameterization import Parameterization, Bounds, Parameter
 from .curve import Curve
 from physicsnemo.sym.constants import diff_str
-from physicsnemo.utils.sdf import signed_distance_field
 
 
 @wp.kernel
@@ -364,44 +363,52 @@ def from_stl(
     def sdf(triangles, airtight, invar, params, compute_sdf_derivatives=False):
         """Simple copy of the sdf function in tessellation.py."""
         points = np.stack([invar["x"], invar["y"], invar["z"]], axis=1)
+        points = np.squeeze(points)
+        if points.ndim == 1:
+            points = points.reshape(1, -1)
 
         minx, maxx, miny, maxy, minz, maxz = Tessellation.find_mins_maxs(points)
         max_dis = max(max((maxx - minx), (maxy - miny)), (maxz - minz))
-        store_triangles = np.array(triangles, dtype=np.float64)
+        store_triangles = np.array(triangles, dtype=np.float32)
         store_triangles[:, :, 0] -= minx
         store_triangles[:, :, 1] -= miny
         store_triangles[:, :, 2] -= minz
         store_triangles *= 1 / max_dis
-        store_triangles = store_triangles.reshape(-1, 3)
+        store_triangles = store_triangles.reshape(-1, 3)  # (n_vertices, 3)
         points[:, 0] -= minx
         points[:, 1] -= miny
         points[:, 2] -= minz
         points *= 1 / max_dis
-        points = points.astype(np.float64).flatten()
+        points = points.astype(np.float32)  # Keep as (n_points, 3)
 
         outputs = {}
         if airtight:
+            # Import locally to avoid pickling issues with multiprocessing
+            import torch
+            from physicsnemo.utils.sdf import signed_distance_field
+
+            torch_vertices = torch.from_numpy(store_triangles)
+            torch_indices = torch.arange(store_triangles.shape[0], dtype=torch.int32)
+            torch_points = torch.from_numpy(points)
+
             sdf_field, sdf_derivative = signed_distance_field(
-                store_triangles,
-                np.arange((store_triangles.shape[0])),
-                points,
-                include_hit_points=True,
+                torch_vertices,
+                torch_indices,
+                torch_points,
+                max_dist=1e8,
+                use_sign_winding_number=False,
             )
-            if isinstance(sdf_field, wp.types.array):
-                sdf_field = sdf_field.numpy()
-            if isinstance(sdf_derivative, wp.types.array):
-                sdf_derivative = sdf_derivative.numpy()
+
+            sdf_field = sdf_field.numpy()
+            sdf_derivative = sdf_derivative.numpy()  # Shape: (n_points, 3)
+
             sdf_field = -np.expand_dims(max_dis * sdf_field, axis=1)
-            sdf_derivative = sdf_derivative.reshape(-1)
         else:
             sdf_field = np.zeros_like(invar["x"])
         outputs["sdf"] = sdf_field
 
         if compute_sdf_derivatives:
             sdf_derivative = -(sdf_derivative - points)
-            sdf_derivative = np.reshape(
-                sdf_derivative, (sdf_derivative.shape[0] // 3, 3)
-            )
             sdf_derivative = sdf_derivative / np.linalg.norm(
                 sdf_derivative, axis=1, keepdims=True
             )

pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools", "setuptools-scm<9.0.0"]
+requires = ["setuptools", "setuptools-scm"]
 build-backend = "setuptools.build_meta"
 
 [project]