warp-lang 1.0.2__py3-none-manylinux2014_x86_64.whl → 1.2.0__py3-none-manylinux2014_x86_64.whl

warp/examples/benchmarks/benchmark_cloth_numpy.py

@@ -1,77 +1,77 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import numpy as np
-
-
-def eval_springs(x, v, indices, rest, ke, kd, f):
-    i = indices[:, 0]
-    j = indices[:, 1]
-
-    xi = x[i]
-    xj = x[j]
-
-    vi = v[i]
-    vj = v[j]
-
-    xij = xi - xj
-    vij = vi - vj
-
-    l = np.linalg.norm(xij, axis=1)
-    l_inv = 1.0 / l
-
-    # normalized spring direction
-    dir = (xij.T * l_inv).T
-
-    c = l - rest
-    dcdt = np.sum(dir * vij, axis=1)
-
-    # damping based on relative velocity.
-    fs = dir.T * (ke * c + kd * dcdt)
-
-    np.add.at(f, i, -fs.T)
-    np.add.at(f, j, fs.T)
-
-
-def integrate_particles(x, v, f, w, dt):
-    g = np.array((0.0, 0.0 - 9.8, 0.0))
-    s = w > 0.0
-
-    a_ext = g * s[:, None]
-
-    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
-    v += ((f.T * w).T + a_ext) * dt
-    x += v * dt
-
-    # clear forces
-    f *= 0.0
-
-
-class NpIntegrator:
-    def __init__(self, cloth):
-        self.cloth = cloth
-
-        self.forces = np.zeros((self.cloth.num_particles, 3), dtype=np.float32)
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            eval_springs(
-                self.cloth.positions,
-                self.cloth.velocities,
-                self.cloth.spring_indices.reshape((self.cloth.num_springs, 2)),
-                self.cloth.spring_lengths,
-                self.cloth.spring_stiffness,
-                self.cloth.spring_damping,
-                self.forces,
-            )
-
-            # integrate
-            integrate_particles(self.cloth.positions, self.cloth.velocities, self.forces, self.cloth.inv_masses, sim_dt)
-
-        return self.cloth.positions
+# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+import numpy as np
+
+
+def eval_springs(x, v, indices, rest, ke, kd, f):
+    i = indices[:, 0]
+    j = indices[:, 1]
+
+    xi = x[i]
+    xj = x[j]
+
+    vi = v[i]
+    vj = v[j]
+
+    xij = xi - xj
+    vij = vi - vj
+
+    l = np.linalg.norm(xij, axis=1)
+    l_inv = 1.0 / l
+
+    # normalized spring direction
+    dir = (xij.T * l_inv).T
+
+    c = l - rest
+    dcdt = np.sum(dir * vij, axis=1)
+
+    # damping based on relative velocity.
+    fs = dir.T * (ke * c + kd * dcdt)
+
+    np.add.at(f, i, -fs.T)
+    np.add.at(f, j, fs.T)
+
+
+def integrate_particles(x, v, f, w, dt):
+    g = np.array((0.0, 0.0 - 9.8, 0.0))
+    s = w > 0.0
+
+    a_ext = g * s[:, None]
+
+    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
+    v += ((f.T * w).T + a_ext) * dt
+    x += v * dt
+
+    # clear forces
+    f *= 0.0
+
+
+class NpIntegrator:
+    def __init__(self, cloth):
+        self.cloth = cloth
+
+        self.forces = np.zeros((self.cloth.num_particles, 3), dtype=np.float32)
+
+    def simulate(self, dt, substeps):
+        sim_dt = dt / substeps
+
+        for _s in range(substeps):
+            eval_springs(
+                self.cloth.positions,
+                self.cloth.velocities,
+                self.cloth.spring_indices.reshape((self.cloth.num_springs, 2)),
+                self.cloth.spring_lengths,
+                self.cloth.spring_stiffness,
+                self.cloth.spring_damping,
+                self.forces,
+            )
+
+            # integrate
+            integrate_particles(self.cloth.positions, self.cloth.velocities, self.forces, self.cloth.inv_masses, sim_dt)
+
+        return self.cloth.positions

warp/examples/benchmarks/benchmark_cloth_pytorch.py

@@ -1,86 +1,86 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import torch
-
-
-def eval_springs(x, v, indices, rest, ke, kd, f):
-    i = indices[:, 0]
-    j = indices[:, 1]
-
-    xi = x[i]
-    xj = x[j]
-
-    vi = v[i]
-    vj = v[j]
-
-    xij = xi - xj
-    vij = vi - vj
-
-    l = torch.linalg.norm(xij, axis=1)
-    l_inv = 1.0 / l
-
-    # normalized spring direction
-    dir = (xij.T * l_inv).T
-
-    c = l - rest
-    dcdt = torch.sum(dir * vij, axis=1)
-
-    # damping based on relative velocity.
-    fs = dir.T * (ke * c + kd * dcdt)
-
-    f.index_add_(dim=0, index=i, source=-fs.T)
-    f.index_add_(dim=0, index=j, source=fs.T)
-
-
-def integrate_particles(x, v, f, g, w, dt):
-    s = w > 0.0
-
-    a_ext = g * s[:, None]
-
-    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
-    v += ((f.T * w).T + a_ext) * dt
-    x += v * dt
-
-    # clear forces
-    f *= 0.0
-
-
-class TrIntegrator:
-    def __init__(self, cloth, device):
-        self.cloth = cloth
-
-        self.positions = torch.tensor(self.cloth.positions, device=device)
-        self.velocities = torch.tensor(self.cloth.velocities, device=device)
-        self.inv_mass = torch.tensor(self.cloth.inv_masses, device=device)
-
-        self.spring_indices = torch.tensor(self.cloth.spring_indices, device=device, dtype=torch.long)
-        self.spring_lengths = torch.tensor(self.cloth.spring_lengths, device=device)
-        self.spring_stiffness = torch.tensor(self.cloth.spring_stiffness, device=device)
-        self.spring_damping = torch.tensor(self.cloth.spring_damping, device=device)
-
-        self.forces = torch.zeros((self.cloth.num_particles, 3), dtype=torch.float32, device=device)
-        self.gravity = g = torch.tensor((0.0, 0.0 - 9.8, 0.0), dtype=torch.float32, device=device)
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            eval_springs(
-                self.positions,
-                self.velocities,
-                self.spring_indices.reshape((self.cloth.num_springs, 2)),
-                self.spring_lengths,
-                self.spring_stiffness,
-                self.spring_damping,
-                self.forces,
-            )
-
-            # integrate
-            integrate_particles(self.positions, self.velocities, self.forces, self.gravity, self.inv_mass, sim_dt)
-
-        return self.positions.cpu().numpy()
+# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+import torch
+
+
+def eval_springs(x, v, indices, rest, ke, kd, f):
+    i = indices[:, 0]
+    j = indices[:, 1]
+
+    xi = x[i]
+    xj = x[j]
+
+    vi = v[i]
+    vj = v[j]
+
+    xij = xi - xj
+    vij = vi - vj
+
+    l = torch.linalg.norm(xij, axis=1)
+    l_inv = 1.0 / l
+
+    # normalized spring direction
+    dir = (xij.T * l_inv).T
+
+    c = l - rest
+    dcdt = torch.sum(dir * vij, axis=1)
+
+    # damping based on relative velocity.
+    fs = dir.T * (ke * c + kd * dcdt)
+
+    f.index_add_(dim=0, index=i, source=-fs.T)
+    f.index_add_(dim=0, index=j, source=fs.T)
+
+
+def integrate_particles(x, v, f, g, w, dt):
+    s = w > 0.0
+
+    a_ext = g * s[:, None]
+
+    # simple semi-implicit Euler. v1 = v0 + a dt, x1 = x0 + v1 dt
+    v += ((f.T * w).T + a_ext) * dt
+    x += v * dt
+
+    # clear forces
+    f *= 0.0
+
+
+class TrIntegrator:
+    def __init__(self, cloth, device):
+        self.cloth = cloth
+
+        self.positions = torch.tensor(self.cloth.positions, device=device)
+        self.velocities = torch.tensor(self.cloth.velocities, device=device)
+        self.inv_mass = torch.tensor(self.cloth.inv_masses, device=device)
+
+        self.spring_indices = torch.tensor(self.cloth.spring_indices, device=device, dtype=torch.long)
+        self.spring_lengths = torch.tensor(self.cloth.spring_lengths, device=device)
+        self.spring_stiffness = torch.tensor(self.cloth.spring_stiffness, device=device)
+        self.spring_damping = torch.tensor(self.cloth.spring_damping, device=device)
+
+        self.forces = torch.zeros((self.cloth.num_particles, 3), dtype=torch.float32, device=device)
+        self.gravity = torch.tensor((0.0, 0.0 - 9.8, 0.0), dtype=torch.float32, device=device)
+
+    def simulate(self, dt, substeps):
+        sim_dt = dt / substeps
+
+        for _s in range(substeps):
+            eval_springs(
+                self.positions,
+                self.velocities,
+                self.spring_indices.reshape((self.cloth.num_springs, 2)),
+                self.spring_lengths,
+                self.spring_stiffness,
+                self.spring_damping,
+                self.forces,
+            )
+
+            # integrate
+            integrate_particles(self.positions, self.velocities, self.forces, self.gravity, self.inv_mass, sim_dt)
+
+        return self.positions.cpu().numpy()

warp/examples/benchmarks/benchmark_cloth_taichi.py

@@ -1,112 +1,112 @@
-# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-import taichi as ti
-import numpy as np
-
-
-@ti.func
-def step(x):
-    ret = 0.0
-    if x < 0:
-        ret = 1
-    return ret
-
-
-@ti.data_oriented
-class TiIntegrator:
-    @ti.kernel
-    def eval_springs(self):
-        for tid in range(self.cloth.num_springs):
-            i = self.spring_indices[2 * tid]
-            j = self.spring_indices[2 * tid + 1]
-
-            ke = self.spring_stiffness[tid]
-            kd = self.spring_damping[tid]
-            rest = self.spring_lengths[tid]
-
-            xi = self.positions[i]
-            xj = self.positions[j]
-
-            vi = self.velocities[i]
-            vj = self.velocities[j]
-
-            xij = xi - xj
-            vij = vi - vj
-
-            l = xij.norm()
-            dir = xij.normalized()
-
-            c = l - rest
-            dcdt = dir.dot(vij)
-
-            fs = dir * (ke * c + kd * dcdt)
-
-            self.forces[i] -= fs
-            self.forces[j] += fs
-
-    @ti.kernel
-    def integrate_particles(self, dt: ti.f32):
-        for tid in range(self.cloth.num_particles):
-            x0 = self.positions[tid]
-            v0 = self.velocities[tid]
-            f0 = self.forces[tid]
-            w = self.inv_mass[tid]
-
-            g = ti.Vector([0.0, 0.0, 0.0])
-
-            if w > 0.0:
-                g = ti.Vector([0.0, -9.81, 0.0])
-
-            v1 = v0 + (f0 * w + g) * dt
-            x1 = x0 + v1 * dt
-
-            self.positions[tid] = x1
-            self.velocities[tid] = v1
-            self.forces[tid] = ti.Vector([0.0, 0.0, 0.0])
-
-    def __init__(self, cloth, device):
-        if device == "cpu":
-            ti.init(arch=ti.cpu)
-        elif device == "cuda":
-            ti.init(arch=ti.gpu)
-        else:
-            raise RuntimeError("Unsupported Taichi device")
-
-        self.cloth = cloth
-
-        self.positions = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
-        self.velocities = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
-        self.inv_mass = ti.field(ti.f32, shape=self.cloth.num_particles)
-
-        self.spring_indices = ti.field(ti.i32, shape=self.cloth.num_springs * 2)
-        self.spring_lengths = ti.field(ti.f32, shape=self.cloth.num_springs)
-        self.spring_stiffness = ti.field(ti.f32, shape=self.cloth.num_springs)
-        self.spring_damping = ti.field(ti.f32, shape=self.cloth.num_springs)
-
-        self.forces = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
-
-        # upload data
-        self.positions.from_numpy(cloth.positions)
-        self.velocities.from_numpy(cloth.velocities)
-        self.inv_mass.from_numpy(cloth.inv_masses)
-        self.forces.from_numpy(np.zeros_like(self.cloth.velocities))
-
-        self.spring_indices.from_numpy(cloth.spring_indices)
-        self.spring_lengths.from_numpy(cloth.spring_lengths)
-        self.spring_stiffness.from_numpy(cloth.spring_stiffness)
-        self.spring_damping.from_numpy(cloth.spring_damping)
-
-    def simulate(self, dt, substeps):
-        sim_dt = dt / substeps
-
-        for s in range(substeps):
-            self.eval_springs()
-
-            self.integrate_particles(sim_dt)
-
-        return self.positions.to_numpy()
+# Copyright (c) 2022 NVIDIA CORPORATION.  All rights reserved.
+# NVIDIA CORPORATION and its licensors retain all intellectual property
+# and proprietary rights in and to this software, related documentation
+# and any modifications thereto.  Any use, reproduction, disclosure or
+# distribution of this software and related documentation without an express
+# license agreement from NVIDIA CORPORATION is strictly prohibited.
+
+import numpy as np
+import taichi as ti
+
+
+@ti.func
+def step(x):
+    ret = 0.0
+    if x < 0:
+        ret = 1
+    return ret
+
+
+@ti.data_oriented
+class TiIntegrator:
+    @ti.kernel
+    def eval_springs(self):
+        for tid in range(self.cloth.num_springs):
+            i = self.spring_indices[2 * tid]
+            j = self.spring_indices[2 * tid + 1]
+
+            ke = self.spring_stiffness[tid]
+            kd = self.spring_damping[tid]
+            rest = self.spring_lengths[tid]
+
+            xi = self.positions[i]
+            xj = self.positions[j]
+
+            vi = self.velocities[i]
+            vj = self.velocities[j]
+
+            xij = xi - xj
+            vij = vi - vj
+
+            l = xij.norm()
+            dir = xij.normalized()
+
+            c = l - rest
+            dcdt = dir.dot(vij)
+
+            fs = dir * (ke * c + kd * dcdt)
+
+            self.forces[i] -= fs
+            self.forces[j] += fs
+
+    @ti.kernel
+    def integrate_particles(self, dt: ti.f32):
+        for tid in range(self.cloth.num_particles):
+            x0 = self.positions[tid]
+            v0 = self.velocities[tid]
+            f0 = self.forces[tid]
+            w = self.inv_mass[tid]
+
+            g = ti.Vector([0.0, 0.0, 0.0])
+
+            if w > 0.0:
+                g = ti.Vector([0.0, -9.81, 0.0])
+
+            v1 = v0 + (f0 * w + g) * dt
+            x1 = x0 + v1 * dt
+
+            self.positions[tid] = x1
+            self.velocities[tid] = v1
+            self.forces[tid] = ti.Vector([0.0, 0.0, 0.0])
+
+    def __init__(self, cloth, device):
+        if device == "cpu":
+            ti.init(arch=ti.cpu)
+        elif device == "cuda":
+            ti.init(arch=ti.gpu)
+        else:
+            raise RuntimeError("Unsupported Taichi device")
+
+        self.cloth = cloth
+
+        self.positions = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
+        self.velocities = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
+        self.inv_mass = ti.field(ti.f32, shape=self.cloth.num_particles)
+
+        self.spring_indices = ti.field(ti.i32, shape=self.cloth.num_springs * 2)
+        self.spring_lengths = ti.field(ti.f32, shape=self.cloth.num_springs)
+        self.spring_stiffness = ti.field(ti.f32, shape=self.cloth.num_springs)
+        self.spring_damping = ti.field(ti.f32, shape=self.cloth.num_springs)
+
+        self.forces = ti.Vector.field(3, dtype=ti.f32, shape=self.cloth.num_particles)
+
+        # upload data
+        self.positions.from_numpy(cloth.positions)
+        self.velocities.from_numpy(cloth.velocities)
+        self.inv_mass.from_numpy(cloth.inv_masses)
+        self.forces.from_numpy(np.zeros_like(self.cloth.velocities))
+
+        self.spring_indices.from_numpy(cloth.spring_indices)
+        self.spring_lengths.from_numpy(cloth.spring_lengths)
+        self.spring_stiffness.from_numpy(cloth.spring_stiffness)
+        self.spring_damping.from_numpy(cloth.spring_damping)
+
+    def simulate(self, dt, substeps):
+        sim_dt = dt / substeps
+
+        for _s in range(substeps):
+            self.eval_springs()
+
+            self.integrate_particles(sim_dt)
+
+        return self.positions.to_numpy()