warp-lang 1.5.0__py3-none-macosx_10_13_universal2.whl → 1.6.0__py3-none-macosx_10_13_universal2.whl

warp/sim/model.py

@@ -578,19 +578,20 @@ class Model:
 
                This setting is not supported by :class:`FeatherstoneIntegrator`.
 
-        joint_limit_lower (array): Joint lower position limits, shape [joint_count], float
-        joint_limit_upper (array): Joint upper position limits, shape [joint_count], float
-        joint_limit_ke (array): Joint position limit stiffness (used by the Euler integrators), shape [joint_count], float
-        joint_limit_kd (array): Joint position limit damping (used by the Euler integrators), shape [joint_count], float
+        joint_limit_lower (array): Joint lower position limits, shape [joint_axis_count], float
+        joint_limit_upper (array): Joint upper position limits, shape [joint_axis_count], float
+        joint_limit_ke (array): Joint position limit stiffness (used by the Euler integrators), shape [joint_axis_count], float
+        joint_limit_kd (array): Joint position limit damping (used by the Euler integrators), shape [joint_axis_count], float
         joint_twist_lower (array): Joint lower twist limit, shape [joint_count], float
         joint_twist_upper (array): Joint upper twist limit, shape [joint_count], float
-        joint_q_start (array): Start index of the first position coordinate per joint, shape [joint_count], int
-        joint_qd_start (array): Start index of the first velocity coordinate per joint, shape [joint_count], int
+        joint_q_start (array): Start index of the first position coordinate per joint (note the last value is an additional sentinel entry to allow for querying the q dimensionality of joint i via ``joint_q_start[i+1] - joint_q_start[i]``), shape [joint_count + 1], int
+        joint_qd_start (array): Start index of the first velocity coordinate per joint (note the last value is an additional sentinel entry to allow for querying the qd dimensionality of joint i via ``joint_qd_start[i+1] - joint_qd_start[i]``), shape [joint_count + 1], int
         articulation_start (array): Articulation start index, shape [articulation_count], int
         joint_name (list): Joint names, shape [joint_count], str
         joint_attach_ke (float): Joint attachment force stiffness (used by :class:`SemiImplicitIntegrator`)
         joint_attach_kd (float): Joint attachment force damping (used by :class:`SemiImplicitIntegrator`)
 
+        soft_contact_radius (float): Contact radius used for self-collisions in the VBD integrator.
         soft_contact_margin (float): Contact margin for generation of soft contacts
         soft_contact_ke (float): Stiffness of soft contacts (used by the Euler integrators)
         soft_contact_kd (float): Damping of soft contacts (used by the Euler integrators)
@@ -761,6 +762,7 @@ class Model:
         self.joint_attach_ke = 1.0e3
         self.joint_attach_kd = 1.0e2
 
+        self.soft_contact_radius = 0.2
         self.soft_contact_margin = 0.2
         self.soft_contact_ke = 1.0e3
         self.soft_contact_kd = 10.0
@@ -1046,6 +1048,8 @@ class Model:
     @property
     def soft_contact_max(self):
         """Maximum number of soft contacts that can be registered"""
+        if self.soft_contact_particle is None:
+            return 0
         return len(self.soft_contact_particle)
 
 
@@ -1442,12 +1446,14 @@ class ModelBuilder:
             self.shape_collision_filter_pairs.add((i + shape_count, j + shape_count))
         for group, shapes in builder.shape_collision_group_map.items():
             if separate_collision_group:
-                group = self.last_collision_group + 1
+                extend_group = self.last_collision_group + 1
             else:
-                group = group + self.last_collision_group if group > -1 else -1
-            if group not in self.shape_collision_group_map:
-                self.shape_collision_group_map[group] = []
-            self.shape_collision_group_map[group].extend([s + shape_count for s in shapes])
+                extend_group = group + self.last_collision_group if group > -1 else -1
+
+            if extend_group not in self.shape_collision_group_map:
+                self.shape_collision_group_map[extend_group] = []
+
+            self.shape_collision_group_map[extend_group].extend([s + shape_count for s in shapes])
 
         # update last collision group counter
         if separate_collision_group:
@@ -1745,8 +1751,8 @@ class ModelBuilder:
         mode: int = JOINT_MODE_FORCE,
         limit_lower: float = -2 * math.pi,
         limit_upper: float = 2 * math.pi,
-        limit_ke: float = default_joint_limit_ke,
-        limit_kd: float = default_joint_limit_kd,
+        limit_ke: float = None,
+        limit_kd: float = None,
         linear_compliance: float = 0.0,
         angular_compliance: float = 0.0,
         armature: float = 1e-2,
@@ -1767,8 +1773,8 @@ class ModelBuilder:
             target_kd: The damping of the joint target
             limit_lower: The lower limit of the joint
             limit_upper: The upper limit of the joint
-            limit_ke: The stiffness of the joint limit
-            limit_kd: The damping of the joint limit
+            limit_ke: The stiffness of the joint limit (None to use the default value :attr:`default_joint_limit_ke`)
+            limit_kd: The damping of the joint limit (None to use the default value :attr:`default_joint_limit_kd`)
             linear_compliance: The linear compliance of the joint
             angular_compliance: The angular compliance of the joint
             armature: Artificial inertia added around the joint axis
@@ -1786,6 +1792,9 @@ class ModelBuilder:
         if child_xform is None:
             child_xform = wp.transform()
 
+        limit_ke = limit_ke if limit_ke is not None else self.default_joint_limit_ke
+        limit_kd = limit_kd if limit_kd is not None else self.default_joint_limit_kd
+
         action = 0.0
         if target is None and mode == JOINT_MODE_TARGET_POSITION:
             action = 0.5 * (limit_lower + limit_upper)
@@ -1832,8 +1841,8 @@ class ModelBuilder:
         mode: int = JOINT_MODE_FORCE,
         limit_lower: float = -1e4,
         limit_upper: float = 1e4,
-        limit_ke: float = default_joint_limit_ke,
-        limit_kd: float = default_joint_limit_kd,
+        limit_ke: float = None,
+        limit_kd: float = None,
         linear_compliance: float = 0.0,
         angular_compliance: float = 0.0,
         armature: float = 1e-2,
@@ -1854,8 +1863,8 @@ class ModelBuilder:
             target_kd: The damping of the joint target
             limit_lower: The lower limit of the joint
             limit_upper: The upper limit of the joint
-            limit_ke: The stiffness of the joint limit
-            limit_kd: The damping of the joint limit
+            limit_ke: The stiffness of the joint limit (None to use the default value :attr:`default_joint_limit_ke`)
+            limit_kd: The damping of the joint limit (None to use the default value :attr:`default_joint_limit_ke`)
             linear_compliance: The linear compliance of the joint
             angular_compliance: The angular compliance of the joint
             armature: Artificial inertia added around the joint axis
@@ -1873,6 +1882,9 @@ class ModelBuilder:
         if child_xform is None:
             child_xform = wp.transform()
 
+        limit_ke = limit_ke if limit_ke is not None else self.default_joint_limit_ke
+        limit_kd = limit_kd if limit_kd is not None else self.default_joint_limit_kd
+
         action = 0.0
         if target is None and mode == JOINT_MODE_TARGET_POSITION:
             action = 0.5 * (limit_lower + limit_upper)
@@ -2521,7 +2533,7 @@ class ModelBuilder:
                 last_dynamic_body_name = self.body_name[last_dynamic_body] if last_dynamic_body > -1 else "world"
                 if verbose:
                     print(
-                        f'Remove fixed joint {joint["name"]} between {parent_name} and {child_name}, '
+                        f"Remove fixed joint {joint['name']} between {parent_name} and {child_name}, "
                         f"merging {child_name} into {last_dynamic_body_name}"
                     )
                 child_id = body_data[child_body]["original_id"]
@@ -2616,11 +2628,12 @@ class ModelBuilder:
             joint_remap[joint["original_id"]] = i
         # update articulation_start
         for i, old_i in enumerate(self.articulation_start):
-            while old_i not in joint_remap:
-                old_i += 1
-                if old_i >= self.joint_count:
+            start_i = old_i
+            while start_i not in joint_remap:
+                start_i += 1
+                if start_i >= self.joint_count:
                     break
-            self.articulation_start[i] = joint_remap.get(old_i, old_i)
+            self.articulation_start[i] = joint_remap.get(start_i, start_i)
         # remove empty articulation starts, i.e. where the start and end are the same
         self.articulation_start = list(set(self.articulation_start))
 
@@ -2772,7 +2785,7 @@ class ModelBuilder:
                 c = np.cross(normal, (0.0, 1.0, 0.0))
                 angle = np.arcsin(np.linalg.norm(c))
                 axis = np.abs(c) / np.linalg.norm(c)
-                rot = wp.quat_from_axis_angle(axis, angle)
+                rot = wp.quat_from_axis_angle(wp.vec3(*axis), wp.float32(angle))
         scale = wp.vec3(width, length, 0.0)
 
         return self._add_shape(
@@ -3498,11 +3511,11 @@ class ModelBuilder:
         i: int,
         j: int,
         k: int,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
     ) -> float:
         """Adds a triangular FEM element between three particles in the system.
 
@@ -3522,6 +3535,11 @@ class ModelBuilder:
             between the particles in their initial configuration.
         """
         # TODO: Expose elastic parameters on a per-element basis
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
 
         # compute basis for 2D rest pose
         p = self.particle_q[i]
@@ -3702,8 +3720,8 @@ class ModelBuilder:
         k: int,
         l: int,
         rest: float = None,
-        edge_ke: float = default_edge_ke,
-        edge_kd: float = default_edge_kd,
+        edge_ke: float = None,
+        edge_kd: float = None,
     ):
         """Adds a bending edge element between four particles in the system.
 
@@ -3724,6 +3742,9 @@ class ModelBuilder:
             winding: (i, k, l), (j, l, k).
 
         """
+        edge_ke = edge_ke if edge_ke is not None else self.default_edge_ke
+        edge_kd = edge_kd if edge_kd is not None else self.default_edge_kd
+
         # compute rest angle
         if rest is None:
             x1 = self.particle_q[i]
@@ -3831,17 +3852,17 @@ class ModelBuilder:
         fix_right: bool = False,
         fix_top: bool = False,
         fix_bottom: bool = False,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
-        edge_ke: float = default_edge_ke,
-        edge_kd: float = default_edge_kd,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
+        edge_ke: float = None,
+        edge_kd: float = None,
         add_springs: bool = False,
-        spring_ke: float = default_spring_ke,
-        spring_kd: float = default_spring_kd,
-        particle_radius: float = default_particle_radius,
+        spring_ke: float = None,
+        spring_kd: float = None,
+        particle_radius: float = None,
     ):
         """Helper to create a regular planar cloth grid
 
@@ -3863,6 +3884,16 @@ class ModelBuilder:
             fix_top: Make the top-most edge of particles kinematic
             fix_bottom: Make the bottom-most edge of particles kinematic
         """
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
+        edge_ke = edge_ke if edge_ke is not None else self.default_edge_ke
+        edge_kd = edge_kd if edge_kd is not None else self.default_edge_kd
+        spring_ke = spring_ke if spring_ke is not None else self.default_spring_ke
+        spring_kd = spring_kd if spring_kd is not None else self.default_spring_kd
+        particle_radius = particle_radius if particle_radius is not None else self.default_particle_radius
 
         def grid_index(x, y, dim_x):
             return y * dim_x + x
@@ -3965,17 +3996,17 @@ class ModelBuilder:
         density: float,
         edge_callback=None,
         face_callback=None,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
-        edge_ke: float = default_edge_ke,
-        edge_kd: float = default_edge_kd,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
+        edge_ke: float = None,
+        edge_kd: float = None,
         add_springs: bool = False,
-        spring_ke: float = default_spring_ke,
-        spring_kd: float = default_spring_kd,
-        particle_radius: float = default_particle_radius,
+        spring_ke: float = None,
+        spring_kd: float = None,
+        particle_radius: float = None,
     ):
         """Helper to create a cloth model from a regular triangle mesh
 
@@ -3996,6 +4027,17 @@ class ModelBuilder:
 
             The mesh should be two manifold.
         """
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
+        edge_ke = edge_ke if edge_ke is not None else self.default_edge_ke
+        edge_kd = edge_kd if edge_kd is not None else self.default_edge_kd
+        spring_ke = spring_ke if spring_ke is not None else self.default_spring_ke
+        spring_kd = spring_kd if spring_kd is not None else self.default_spring_kd
+        particle_radius = particle_radius if particle_radius is not None else self.default_particle_radius
+
         num_tris = int(len(indices) / 3)
 
         start_vertex = len(self.particle_q)
@@ -4073,9 +4115,11 @@ class ModelBuilder:
         cell_z: float,
         mass: float,
         jitter: float,
-        radius_mean: float = default_particle_radius,
+        radius_mean: float = None,
         radius_std: float = 0.0,
     ):
+        radius_mean = radius_mean if radius_mean is not None else self.default_particle_radius
+
         rng = np.random.default_rng(42)
         for z in range(dim_z):
             for y in range(dim_y):
@@ -4110,11 +4154,11 @@ class ModelBuilder:
         fix_right: bool = False,
         fix_top: bool = False,
         fix_bottom: bool = False,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
     ):
         """Helper to create a rectangular tetrahedral FEM grid
 
@@ -4141,6 +4185,11 @@ class ModelBuilder:
             fix_top: Make the top-most edge of particles kinematic
             fix_bottom: Make the bottom-most edge of particles kinematic
         """
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
 
         start_vertex = len(self.particle_q)
 
@@ -4232,11 +4281,11 @@ class ModelBuilder:
         k_mu: float,
         k_lambda: float,
         k_damp: float,
-        tri_ke: float = default_tri_ke,
-        tri_ka: float = default_tri_ka,
-        tri_kd: float = default_tri_kd,
-        tri_drag: float = default_tri_drag,
-        tri_lift: float = default_tri_lift,
+        tri_ke: float = None,
+        tri_ka: float = None,
+        tri_kd: float = None,
+        tri_drag: float = None,
+        tri_lift: float = None,
     ):
         """Helper to create a tetrahedral model from an input tetrahedral mesh
 
@@ -4251,6 +4300,12 @@ class ModelBuilder:
             k_lambda: The second elastic Lame parameter
             k_damp: The damping stiffness
         """
+        tri_ke = tri_ke if tri_ke is not None else self.default_tri_ke
+        tri_ka = tri_ka if tri_ka is not None else self.default_tri_ka
+        tri_kd = tri_kd if tri_kd is not None else self.default_tri_kd
+        tri_drag = tri_drag if tri_drag is not None else self.default_tri_drag
+        tri_lift = tri_lift if tri_lift is not None else self.default_tri_lift
+
         num_tets = int(len(indices) / 4)
 
         start_vertex = len(self.particle_q)
@@ -4269,8 +4324,7 @@ class ModelBuilder:
         pos = wp.vec3(pos[0], pos[1], pos[2])
         # add particles
         for v in vertices:
-            v = wp.vec3(v[0], v[1], v[2])
-            p = wp.quat_rotate(rot, v * scale) + pos
+            p = wp.quat_rotate(rot, wp.vec3(v[0], v[1], v[2]) * scale) + pos
 
             self.add_particle(p, vel, 0.0)
 
@@ -4342,16 +4396,22 @@ class ModelBuilder:
         self,
         normal=None,
         offset=0.0,
-        ke: float = default_shape_ke,
-        kd: float = default_shape_kd,
-        kf: float = default_shape_kf,
-        mu: float = default_shape_mu,
-        restitution: float = default_shape_restitution,
+        ke: float = None,
+        kd: float = None,
+        kf: float = None,
+        mu: float = None,
+        restitution: float = None,
     ):
         """
         Creates a ground plane for the world. If the normal is not specified,
         the up_vector of the ModelBuilder is used.
         """
+        ke = ke if ke is not None else self.default_shape_ke
+        kd = kd if kd is not None else self.default_shape_kd
+        kf = kf if kf is not None else self.default_shape_kf
+        mu = mu if mu is not None else self.default_shape_mu
+        restitution = restitution if restitution is not None else self.default_shape_restitution
+
         if normal is None:
             normal = self.up_vector
         self._ground_params = {
@@ -4402,16 +4462,18 @@ class ModelBuilder:
             balance_colors: Whether to apply the color balancing algorithm to balance the size of each color
             target_max_min_color_ratio: the color balancing algorithm will stop when the ratio between the largest color and
                 the smallest color reaches this value
-            algorithm: Value should an enum type of ColoringAlgorithm, otherwise it will raise an error. ColoringAlgorithm.mcs means using the MCS coloring algorithm,
+            algorithm: Value should be an enum type of ColoringAlgorithm, otherwise it will raise an error. ColoringAlgorithm.mcs means using the MCS coloring algorithm,
                 while ColoringAlgorithm.ordered_greedy means using the degree-ordered greedy algorithm. The MCS algorithm typically generates 30% to 50% fewer colors
                 compared to the ordered greedy algorithm, while maintaining the same linear complexity. Although MCS has a constant overhead that makes it about twice
                 as slow as the greedy algorithm, it produces significantly better coloring results. We recommend using MCS, especially if coloring is only part of the
-                preprocessing stage.e.
+                preprocessing.
 
         Note:
 
             References to the coloring algorithm:
+
             MCS: Pereira, F. M. Q., & Palsberg, J. (2005, November). Register allocation via coloring of chordal graphs. In Asian Symposium on Programming Languages and Systems (pp. 315-329). Berlin, Heidelberg: Springer Berlin Heidelberg.
+
             Ordered Greedy: Ton-That, Q. M., Kry, P. G., & Andrews, S. (2023). Parallel block Neo-Hookean XPBD using graph clustering. Computers & Graphics, 110, 1-10.
 
         """

warp/sparse.py

@@ -8,7 +8,7 @@ from warp.types import Array, Cols, Rows, Scalar, Vector
 
 # typing hints
 
-_BlockType = TypeVar("BlockType")
+_BlockType = TypeVar("BlockType")  # noqa: PLC0132
 
 
 class _MatrixBlockType(Generic[Rows, Cols, Scalar]):