Tangential Collisions¶

class ipctk.TangentialCollisions¶

Bases: pybind11_object

Public Data Attributes:

`vv_collisions`
`ev_collisions`
`ee_collisions`
`fv_collisions`

Public Methods:

`__init__`(self)
`build`(args, *kwargs)	Overloaded function.
`__len__`(self)	Get the number of friction collisions.
`empty`(self)	Get if the friction collisions are empty.
`clear`(self)	Clear the friction collisions.
`reset_lagged_anisotropic_friction_coefficients`(self)	Set lagged effective μ to scalar mu_s/mu_k on each collision (done automatically after build).
`update_lagged_anisotropic_friction_coefficients`(...)	Refresh matchstick effective μ from lagged geometry and slip.
`__getitem__`(self, i)	Get a reference to collision at index i.
`default_blend_mu`(mu0, mu1)

Inherited from pybind11_object

Private Methods:

`_pybind11_conduit_v1_`

__annotations__ = {}¶

__getitem__(self, i: SupportsInt) → ipctk.TangentialCollision¶

Get a reference to collision at index i.

Parameters:¶

i: SupportsInt¶: The index of the collision.

Returns:¶

A reference to the collision.

__init__(self)¶

__len__(self) → int¶: Get the number of friction collisions.

__module__ = 'ipctk'¶

_pybind11_conduit_v1_()¶

build(*args, **kwargs)¶

Overloaded function.

build(self: ipctk.TangentialCollisions, mesh: ipc::CollisionMesh, vertices: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.f_contiguous”], collisions: ipctk.NormalCollisions, normal_potential: ipc::NormalPotential, mu: typing.SupportsFloat) -> None
build(self: ipctk.TangentialCollisions, mesh: ipc::CollisionMesh, vertices: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.f_contiguous”], collisions: ipctk.NormalCollisions, normal_potential: ipc::NormalPotential, mu_s: typing.SupportsFloat, mu_k: typing.SupportsFloat) -> None
build(self: ipctk.TangentialCollisions, mesh: ipc::CollisionMesh, vertices: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.f_contiguous”], collisions: ipctk.NormalCollisions, normal_potential: ipc::NormalPotential, mu_s: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], mu_k: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]) -> None
build(self: ipctk.TangentialCollisions, mesh: ipc::CollisionMesh, vertices: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.f_contiguous”], collisions: ipctk.NormalCollisions, normal_potential: ipc::NormalPotential, mu_s: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], mu_k: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], blend_mu: collections.abc.Callable[[typing.SupportsFloat, typing.SupportsFloat], float]) -> None

clear(self) → None¶: Clear the friction collisions.

static default_blend_mu(mu0: SupportsFloat, mu1: SupportsFloat) → float¶

property ee_collisions : list[ipc::EdgeEdgeTangentialCollision]¶

empty(self) → bool¶: Get if the friction collisions are empty.

property ev_collisions : list[ipc::EdgeVertexTangentialCollision]¶

property fv_collisions : list[ipc::FaceVertexTangentialCollision]¶

reset_lagged_anisotropic_friction_coefficients(self) → None¶: Set lagged effective μ to scalar mu_s/mu_k on each collision (done automatically after build).

update_lagged_anisotropic_friction_coefficients(self: ipctk.TangentialCollisions, mesh: ipc::CollisionMesh, rest_positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.f_contiguous"], lagged_displacements: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.f_contiguous"], velocities: typing.Annotated[numpy.typing.NDArray[numpy.float64], "[m, n]", "flags.f_contiguous"]) → None¶: Refresh matchstick effective μ from lagged geometry and slip. Call when mu_s_aniso is nonzero (e.g. each Newton iteration).

property vv_collisions : list[ipc::VertexVertexTangentialCollision]¶

Tangential Collision¶

class ipctk.TangentialCollision¶

Bases: CollisionStencil

Public Data Attributes:

`dim`	Get the dimension of the collision.
`ndof`	Get the number of degrees of freedom for the collision.
`normal_force_magnitude`	Normal force magnitude
`mu_s`	Ratio between normal and static tangential forces (e.g., friction coefficient)
`mu_k`	Ratio between normal and kinetic tangential forces (e.g., friction coefficient)
`mu_aniso`	Tangential anisotropy scaling in the collision's tangent basis.
`mu_s_aniso`	Static friction ellipse axes (2D, one per tangent).
`mu_k_aniso`	Kinetic friction ellipse axes (2D, one per tangent).
`mu_s_effective_lagged`	Lagged matchstick effective static μ (refresh via TangentialCollisions.update_lagged_anisotropic_friction_coefficients).
`mu_k_effective_lagged`	Lagged matchstick effective kinetic μ.
`weight`	Weight
`weight_gradient`	Gradient of weight with respect to all DOF
`closest_point`	Barycentric coordinates of the closest point(s)
`tangent_basis`	Tangent basis of the collision (max size 3×2)

Public Methods:

`__init__`(args, *kwargs)
`compute_tangent_basis`(self, positions)	Compute the tangent basis of the collision.
`compute_tangent_basis_jacobian`(self, positions)	Compute the Jacobian of the tangent basis of the collision.
`compute_closest_point`(self, positions)	Compute the barycentric coordinates of the closest point.
`compute_closest_point_jacobian`(self, positions)	Compute the Jacobian of the barycentric coordinates of the closest point.
`relative_velocity`(self, velocities)	Compute the relative velocity of the collision.
`relative_velocity_jacobian`(args, *kwargs)	Overloaded function.
`relative_velocity_dx_dbeta`(self, closest_point)	Construct the Jacobian of the relative velocity premultiplier wrt the closest points.

Inherited from CollisionStencil

`__init__`(args, *kwargs)
`num_vertices`(self)	Get the number of vertices in the collision stencil.
`dim`(self, ndof)	Get the dimension of the collision stencil.
`vertex_ids`(self, edges, faces)	Get the vertex IDs of the collision stencil.
`vertices`(self, vertices, edges, faces)	Get the vertex attributes of the collision stencil.
`dof`(self, X, edges, faces)	Select this stencil's DOF from the full matrix of DOF.
`compute_distance`(args, *kwargs)	Overloaded function.
`compute_distance_gradient`(args, *kwargs)	Overloaded function.
`compute_distance_hessian`(args, *kwargs)	Overloaded function.
`compute_coefficients`(args, *kwargs)	Overloaded function.
`ccd`(self, vertices_t0, ], vertices_t1, ], ...)	Perform narrow-phase CCD on the candidate.
`print_ccd_query`(self, vertices_t0, vertices_t1)	Print the CCD query to cout.
`compute_distance_vector`(args, *kwargs)	Overloaded function.
`compute_distance_vector_with_coefficients`(...)	Compute the distance vector and the coefficients together.
`compute_distance_vector_jacobian`(self, positions)	Compute the Jacobian of the distance vector w.r.t.
`diag_distance_vector_outer`(coeffs, dim)	Compute diag((dt/dx)(dt/dx)^T) efficiently (Eq.
`diag_distance_vector_t_outer`(coeffs, ...)	Compute diag((dt/dx * t)(dt/dx * t)^T) efficiently (Eq.
`contract_distance_vector_jacobian`(coeffs, p, dim)	Compute p^T (dt/dx) efficiently as sum(c_i * p_i) (Eqs.

Inherited from pybind11_object

Private Methods:

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__annotations__ = {}¶

__init__(*args, **kwargs)¶

__module__ = 'ipctk'¶

_pybind11_conduit_v1_()¶

property closest_point : Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶: Barycentric coordinates of the closest point(s)

compute_closest_point(self, positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Compute the barycentric coordinates of the closest point.

Parameters:¶

positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶: Collision stencil’s vertex positions.

Returns:¶

Barycentric coordinates of the closest point.

compute_closest_point_jacobian(self, positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']¶

Compute the Jacobian of the barycentric coordinates of the closest point.

Parameters:¶

positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶: Collision stencil’s vertex positions.

Returns:¶

Jacobian of the barycentric coordinates of the closest point.

compute_tangent_basis(self, positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']¶

Compute the tangent basis of the collision.

Parameters:¶

positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶: Collision stencil’s vertex positions.

Returns:¶

Tangent basis of the collision.

compute_tangent_basis_jacobian(self, positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']¶

Compute the Jacobian of the tangent basis of the collision.

Parameters:¶

positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶: Collision stencil’s vertex positions.

Returns:¶

Jacobian of the tangent basis of the collision.

property dim : int¶: Get the dimension of the collision.

property mu_aniso : Annotated[numpy.typing.NDArray[numpy.float64], '[2, 1]']¶: Tangential anisotropy scaling in the collision’s tangent basis. (1,1) = isotropic (default). Positive entries are recommended for physically meaningful anisotropic scaling. Scales tau before evaluating friction.

property mu_k : float¶: Ratio between normal and kinetic tangential forces (e.g., friction coefficient)

property mu_k_aniso : Annotated[numpy.typing.NDArray[numpy.float64], '[2, 1]']¶: Kinetic friction ellipse axes (2D, one per tangent). Zero → scalar mu_k. Matchstick model (CGF 2019, DOI 10.1111/cgf.13885).

property mu_k_effective_lagged : float¶: Lagged matchstick effective kinetic μ.

property mu_s : float¶: Ratio between normal and static tangential forces (e.g., friction coefficient)

property mu_s_aniso : Annotated[numpy.typing.NDArray[numpy.float64], '[2, 1]']¶: Static friction ellipse axes (2D, one per tangent). Zero → scalar mu_s. Matchstick model (CGF 2019, DOI 10.1111/cgf.13885).

property mu_s_effective_lagged : float¶: Lagged matchstick effective static μ (refresh via TangentialCollisions.update_lagged_anisotropic_friction_coefficients).

property ndof : int¶: Get the number of degrees of freedom for the collision.

property normal_force_magnitude : float¶: Normal force magnitude

relative_velocity(self, velocities: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶

Compute the relative velocity of the collision.

Parameters:¶

velocities: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶: Collision stencil’s vertex velocities.

Returns:¶

Relative velocity of the collision.

relative_velocity_dx_dbeta(self, closest_point: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']¶

Construct the Jacobian of the relative velocity premultiplier wrt the closest points.

Parameters:¶

closest_point: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']¶: Barycentric coordinates of the closest point.

Returns:¶

Jacobian of the relative velocity premultiplier wrt the closest points.

relative_velocity_jacobian(*args, **kwargs)¶

Overloaded function.

relative_velocity_jacobian(self: ipctk.TangentialCollision) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

Construct the premultiplier matrix for the relative velocity.

Note:
Uses the cached closest point.

Returns:
A matrix M such that relative_velocity = M * velocities.
relative_velocity_jacobian(self: ipctk.TangentialCollision, closest_point: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

Construct the premultiplier matrix for the relative velocity.

Parameters:
closest_point: Barycentric coordinates of the closest point.

Returns:
A matrix M such that relative_velocity = M * velocities.

property tangent_basis : Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]']¶: Tangent basis of the collision (max size 3×2)

property weight : float¶: Weight

property weight_gradient : scipy.sparse.csc_matrix[numpy.float64]¶: Gradient of weight with respect to all DOF

Vertex-Vertex Tangential Collision¶

class ipctk.VertexVertexTangentialCollision¶

Bases: VertexVertexCandidate, TangentialCollision

Public Data Attributes:

Inherited from VertexVertexCandidate

`vertex0_id`	ID of the first vertex
`vertex1_id`	ID of the second vertex

Inherited from TangentialCollision

`dim`	Get the dimension of the collision.
`ndof`	Get the number of degrees of freedom for the collision.
`normal_force_magnitude`	Normal force magnitude
`mu_s`	Ratio between normal and static tangential forces (e.g., friction coefficient)
`mu_k`	Ratio between normal and kinetic tangential forces (e.g., friction coefficient)
`mu_aniso`	Tangential anisotropy scaling in the collision's tangent basis.
`mu_s_aniso`	Static friction ellipse axes (2D, one per tangent).
`mu_k_aniso`	Kinetic friction ellipse axes (2D, one per tangent).
`mu_s_effective_lagged`	Lagged matchstick effective static μ (refresh via TangentialCollisions.update_lagged_anisotropic_friction_coefficients).
`mu_k_effective_lagged`	Lagged matchstick effective kinetic μ.
`weight`	Weight
`weight_gradient`	Gradient of weight with respect to all DOF
`closest_point`	Barycentric coordinates of the closest point(s)
`tangent_basis`	Tangent basis of the collision (max size 3×2)

Public Methods:

`__init__`(args, *kwargs)	Overloaded function.

Inherited from VertexVertexCandidate

`__init__`(args, *kwargs)	Overloaded function.
`__str__`(self)
`__repr__`(self)
`__eq__`(self, other)
`__ne__`(self, other)
`__lt__`(self, other)	Compare EdgeVertexCandidates for sorting.

Inherited from TangentialCollision

`__init__`(args, *kwargs)
`compute_tangent_basis`(self, positions)	Compute the tangent basis of the collision.
`compute_tangent_basis_jacobian`(self, positions)	Compute the Jacobian of the tangent basis of the collision.
`compute_closest_point`(self, positions)	Compute the barycentric coordinates of the closest point.
`compute_closest_point_jacobian`(self, positions)	Compute the Jacobian of the barycentric coordinates of the closest point.
`relative_velocity`(self, velocities)	Compute the relative velocity of the collision.
`relative_velocity_jacobian`(args, *kwargs)	Overloaded function.
`relative_velocity_dx_dbeta`(self, closest_point)	Construct the Jacobian of the relative velocity premultiplier wrt the closest points.

Inherited from CollisionStencil

`__init__`(args, *kwargs)
`num_vertices`(self)	Get the number of vertices in the collision stencil.
`dim`(self, ndof)	Get the dimension of the collision stencil.
`vertex_ids`(self, edges, faces)	Get the vertex IDs of the collision stencil.
`vertices`(self, vertices, edges, faces)	Get the vertex attributes of the collision stencil.
`dof`(self, X, edges, faces)	Select this stencil's DOF from the full matrix of DOF.
`compute_distance`(args, *kwargs)	Overloaded function.
`compute_distance_gradient`(args, *kwargs)	Overloaded function.
`compute_distance_hessian`(args, *kwargs)	Overloaded function.
`compute_coefficients`(args, *kwargs)	Overloaded function.
`ccd`(self, vertices_t0, ], vertices_t1, ], ...)	Perform narrow-phase CCD on the candidate.
`print_ccd_query`(self, vertices_t0, vertices_t1)	Print the CCD query to cout.
`compute_distance_vector`(args, *kwargs)	Overloaded function.
`compute_distance_vector_with_coefficients`(...)	Compute the distance vector and the coefficients together.
`compute_distance_vector_jacobian`(self, positions)	Compute the Jacobian of the distance vector w.r.t.
`diag_distance_vector_outer`(coeffs, dim)	Compute diag((dt/dx)(dt/dx)^T) efficiently (Eq.
`diag_distance_vector_t_outer`(coeffs, ...)	Compute diag((dt/dx * t)(dt/dx * t)^T) efficiently (Eq.
`contract_distance_vector_jacobian`(coeffs, p, dim)	Compute p^T (dt/dx) efficiently as sum(c_i * p_i) (Eqs.

Inherited from pybind11_object

Private Methods:

`_pybind11_conduit_v1_`

Inherited from VertexVertexCandidate

`_pybind11_conduit_v1_`

Inherited from TangentialCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.VertexVertexTangentialCollision, collision: ipctk.VertexVertexNormalCollision) -> None
__init__(self: ipctk.VertexVertexTangentialCollision, collision: ipctk.VertexVertexNormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], normal_potential: ipc::NormalPotential) -> None

__module__ = 'ipctk'¶

_pybind11_conduit_v1_()¶

Edge-Vertex Tangential Collision¶

class ipctk.EdgeVertexTangentialCollision¶

Bases: EdgeVertexCandidate, TangentialCollision

Public Data Attributes:

Inherited from EdgeVertexCandidate

`edge_id`	ID of the edge
`vertex_id`	ID of the vertex

Inherited from TangentialCollision

`dim`	Get the dimension of the collision.
`ndof`	Get the number of degrees of freedom for the collision.
`normal_force_magnitude`	Normal force magnitude
`mu_s`	Ratio between normal and static tangential forces (e.g., friction coefficient)
`mu_k`	Ratio between normal and kinetic tangential forces (e.g., friction coefficient)
`mu_aniso`	Tangential anisotropy scaling in the collision's tangent basis.
`mu_s_aniso`	Static friction ellipse axes (2D, one per tangent).
`mu_k_aniso`	Kinetic friction ellipse axes (2D, one per tangent).
`mu_s_effective_lagged`	Lagged matchstick effective static μ (refresh via TangentialCollisions.update_lagged_anisotropic_friction_coefficients).
`mu_k_effective_lagged`	Lagged matchstick effective kinetic μ.
`weight`	Weight
`weight_gradient`	Gradient of weight with respect to all DOF
`closest_point`	Barycentric coordinates of the closest point(s)
`tangent_basis`	Tangent basis of the collision (max size 3×2)

Public Methods:

`__init__`(args, *kwargs)	Overloaded function.

Inherited from EdgeVertexCandidate

`__init__`(args, *kwargs)	Overloaded function.
`known_dtype`(self)
`__str__`(self)
`__repr__`(self)
`__eq__`(self, other)
`__ne__`(self, other)
`__lt__`(self, other)	Compare EdgeVertexCandidates for sorting.

Inherited from TangentialCollision

`__init__`(args, *kwargs)
`compute_tangent_basis`(self, positions)	Compute the tangent basis of the collision.
`compute_tangent_basis_jacobian`(self, positions)	Compute the Jacobian of the tangent basis of the collision.
`compute_closest_point`(self, positions)	Compute the barycentric coordinates of the closest point.
`compute_closest_point_jacobian`(self, positions)	Compute the Jacobian of the barycentric coordinates of the closest point.
`relative_velocity`(self, velocities)	Compute the relative velocity of the collision.
`relative_velocity_jacobian`(args, *kwargs)	Overloaded function.
`relative_velocity_dx_dbeta`(self, closest_point)	Construct the Jacobian of the relative velocity premultiplier wrt the closest points.

Inherited from CollisionStencil

`__init__`(args, *kwargs)
`num_vertices`(self)	Get the number of vertices in the collision stencil.
`dim`(self, ndof)	Get the dimension of the collision stencil.
`vertex_ids`(self, edges, faces)	Get the vertex IDs of the collision stencil.
`vertices`(self, vertices, edges, faces)	Get the vertex attributes of the collision stencil.
`dof`(self, X, edges, faces)	Select this stencil's DOF from the full matrix of DOF.
`compute_distance`(args, *kwargs)	Overloaded function.
`compute_distance_gradient`(args, *kwargs)	Overloaded function.
`compute_distance_hessian`(args, *kwargs)	Overloaded function.
`compute_coefficients`(args, *kwargs)	Overloaded function.
`ccd`(self, vertices_t0, ], vertices_t1, ], ...)	Perform narrow-phase CCD on the candidate.
`print_ccd_query`(self, vertices_t0, vertices_t1)	Print the CCD query to cout.
`compute_distance_vector`(args, *kwargs)	Overloaded function.
`compute_distance_vector_with_coefficients`(...)	Compute the distance vector and the coefficients together.
`compute_distance_vector_jacobian`(self, positions)	Compute the Jacobian of the distance vector w.r.t.
`diag_distance_vector_outer`(coeffs, dim)	Compute diag((dt/dx)(dt/dx)^T) efficiently (Eq.
`diag_distance_vector_t_outer`(coeffs, ...)	Compute diag((dt/dx * t)(dt/dx * t)^T) efficiently (Eq.
`contract_distance_vector_jacobian`(coeffs, p, dim)	Compute p^T (dt/dx) efficiently as sum(c_i * p_i) (Eqs.

Inherited from pybind11_object

Private Methods:

`_pybind11_conduit_v1_`

Inherited from EdgeVertexCandidate

`_pybind11_conduit_v1_`

Inherited from TangentialCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.EdgeVertexTangentialCollision, collision: ipctk.EdgeVertexNormalCollision) -> None
__init__(self: ipctk.EdgeVertexTangentialCollision, collision: ipctk.EdgeVertexNormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], normal_potential: ipc::NormalPotential) -> None

__module__ = 'ipctk'¶

_pybind11_conduit_v1_()¶

Edge-Edge Tangential Collision¶

class ipctk.EdgeEdgeTangentialCollision¶

Bases: EdgeEdgeCandidate, TangentialCollision

Public Data Attributes:

Inherited from EdgeEdgeCandidate

`edge0_id`	ID of the first edge.
`edge1_id`	ID of the second edge.

Inherited from TangentialCollision

`dim`	Get the dimension of the collision.
`ndof`	Get the number of degrees of freedom for the collision.
`normal_force_magnitude`	Normal force magnitude
`mu_s`	Ratio between normal and static tangential forces (e.g., friction coefficient)
`mu_k`	Ratio between normal and kinetic tangential forces (e.g., friction coefficient)
`mu_aniso`	Tangential anisotropy scaling in the collision's tangent basis.
`mu_s_aniso`	Static friction ellipse axes (2D, one per tangent).
`mu_k_aniso`	Kinetic friction ellipse axes (2D, one per tangent).
`mu_s_effective_lagged`	Lagged matchstick effective static μ (refresh via TangentialCollisions.update_lagged_anisotropic_friction_coefficients).
`mu_k_effective_lagged`	Lagged matchstick effective kinetic μ.
`weight`	Weight
`weight_gradient`	Gradient of weight with respect to all DOF
`closest_point`	Barycentric coordinates of the closest point(s)
`tangent_basis`	Tangent basis of the collision (max size 3×2)

Public Methods:

`__init__`(args, *kwargs)	Overloaded function.

Inherited from EdgeEdgeCandidate

`__init__`(args, *kwargs)	Overloaded function.
`known_dtype`(self)
`__str__`(self)
`__repr__`(self)
`__eq__`(self, other)
`__ne__`(self, other)
`__lt__`(self, other)	Compare EdgeEdgeCandidates for sorting.

Inherited from TangentialCollision

`__init__`(args, *kwargs)
`compute_tangent_basis`(self, positions)	Compute the tangent basis of the collision.
`compute_tangent_basis_jacobian`(self, positions)	Compute the Jacobian of the tangent basis of the collision.
`compute_closest_point`(self, positions)	Compute the barycentric coordinates of the closest point.
`compute_closest_point_jacobian`(self, positions)	Compute the Jacobian of the barycentric coordinates of the closest point.
`relative_velocity`(self, velocities)	Compute the relative velocity of the collision.
`relative_velocity_jacobian`(args, *kwargs)	Overloaded function.
`relative_velocity_dx_dbeta`(self, closest_point)	Construct the Jacobian of the relative velocity premultiplier wrt the closest points.

Inherited from CollisionStencil

`__init__`(args, *kwargs)
`num_vertices`(self)	Get the number of vertices in the collision stencil.
`dim`(self, ndof)	Get the dimension of the collision stencil.
`vertex_ids`(self, edges, faces)	Get the vertex IDs of the collision stencil.
`vertices`(self, vertices, edges, faces)	Get the vertex attributes of the collision stencil.
`dof`(self, X, edges, faces)	Select this stencil's DOF from the full matrix of DOF.
`compute_distance`(args, *kwargs)	Overloaded function.
`compute_distance_gradient`(args, *kwargs)	Overloaded function.
`compute_distance_hessian`(args, *kwargs)	Overloaded function.
`compute_coefficients`(args, *kwargs)	Overloaded function.
`ccd`(self, vertices_t0, ], vertices_t1, ], ...)	Perform narrow-phase CCD on the candidate.
`print_ccd_query`(self, vertices_t0, vertices_t1)	Print the CCD query to cout.
`compute_distance_vector`(args, *kwargs)	Overloaded function.
`compute_distance_vector_with_coefficients`(...)	Compute the distance vector and the coefficients together.
`compute_distance_vector_jacobian`(self, positions)	Compute the Jacobian of the distance vector w.r.t.
`diag_distance_vector_outer`(coeffs, dim)	Compute diag((dt/dx)(dt/dx)^T) efficiently (Eq.
`diag_distance_vector_t_outer`(coeffs, ...)	Compute diag((dt/dx * t)(dt/dx * t)^T) efficiently (Eq.
`contract_distance_vector_jacobian`(coeffs, p, dim)	Compute p^T (dt/dx) efficiently as sum(c_i * p_i) (Eqs.

Inherited from pybind11_object

Private Methods:

`_pybind11_conduit_v1_`

Inherited from EdgeEdgeCandidate

`_pybind11_conduit_v1_`

Inherited from TangentialCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.EdgeEdgeTangentialCollision, collision: ipctk.EdgeEdgeNormalCollision) -> None
__init__(self: ipctk.EdgeEdgeTangentialCollision, collision: ipctk.EdgeEdgeNormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], normal_potential: ipc::NormalPotential) -> None

__module__ = 'ipctk'¶

_pybind11_conduit_v1_()¶

Face-Vertex Tangential Collision¶

class ipctk.FaceVertexTangentialCollision¶

Bases: FaceVertexCandidate, TangentialCollision

Public Data Attributes:

Inherited from FaceVertexCandidate

`face_id`	ID of the face
`vertex_id`	ID of the vertex

Inherited from TangentialCollision

`dim`	Get the dimension of the collision.
`ndof`	Get the number of degrees of freedom for the collision.
`normal_force_magnitude`	Normal force magnitude
`mu_s`	Ratio between normal and static tangential forces (e.g., friction coefficient)
`mu_k`	Ratio between normal and kinetic tangential forces (e.g., friction coefficient)
`mu_aniso`	Tangential anisotropy scaling in the collision's tangent basis.
`mu_s_aniso`	Static friction ellipse axes (2D, one per tangent).
`mu_k_aniso`	Kinetic friction ellipse axes (2D, one per tangent).
`mu_s_effective_lagged`	Lagged matchstick effective static μ (refresh via TangentialCollisions.update_lagged_anisotropic_friction_coefficients).
`mu_k_effective_lagged`	Lagged matchstick effective kinetic μ.
`weight`	Weight
`weight_gradient`	Gradient of weight with respect to all DOF
`closest_point`	Barycentric coordinates of the closest point(s)
`tangent_basis`	Tangent basis of the collision (max size 3×2)

Public Methods:

`__init__`(args, *kwargs)	Overloaded function.

Inherited from FaceVertexCandidate

`__init__`(args, *kwargs)	Overloaded function.
`known_dtype`(self)
`__str__`(self)
`__repr__`(self)
`__eq__`(self, other)
`__ne__`(self, other)
`__lt__`(self, other)	Compare FaceVertexCandidate for sorting.

Inherited from TangentialCollision

`__init__`(args, *kwargs)
`compute_tangent_basis`(self, positions)	Compute the tangent basis of the collision.
`compute_tangent_basis_jacobian`(self, positions)	Compute the Jacobian of the tangent basis of the collision.
`compute_closest_point`(self, positions)	Compute the barycentric coordinates of the closest point.
`compute_closest_point_jacobian`(self, positions)	Compute the Jacobian of the barycentric coordinates of the closest point.
`relative_velocity`(self, velocities)	Compute the relative velocity of the collision.
`relative_velocity_jacobian`(args, *kwargs)	Overloaded function.
`relative_velocity_dx_dbeta`(self, closest_point)	Construct the Jacobian of the relative velocity premultiplier wrt the closest points.

Inherited from CollisionStencil

`__init__`(args, *kwargs)
`num_vertices`(self)	Get the number of vertices in the collision stencil.
`dim`(self, ndof)	Get the dimension of the collision stencil.
`vertex_ids`(self, edges, faces)	Get the vertex IDs of the collision stencil.
`vertices`(self, vertices, edges, faces)	Get the vertex attributes of the collision stencil.
`dof`(self, X, edges, faces)	Select this stencil's DOF from the full matrix of DOF.
`compute_distance`(args, *kwargs)	Overloaded function.
`compute_distance_gradient`(args, *kwargs)	Overloaded function.
`compute_distance_hessian`(args, *kwargs)	Overloaded function.
`compute_coefficients`(args, *kwargs)	Overloaded function.
`ccd`(self, vertices_t0, ], vertices_t1, ], ...)	Perform narrow-phase CCD on the candidate.
`print_ccd_query`(self, vertices_t0, vertices_t1)	Print the CCD query to cout.
`compute_distance_vector`(args, *kwargs)	Overloaded function.
`compute_distance_vector_with_coefficients`(...)	Compute the distance vector and the coefficients together.
`compute_distance_vector_jacobian`(self, positions)	Compute the Jacobian of the distance vector w.r.t.
`diag_distance_vector_outer`(coeffs, dim)	Compute diag((dt/dx)(dt/dx)^T) efficiently (Eq.
`diag_distance_vector_t_outer`(coeffs, ...)	Compute diag((dt/dx * t)(dt/dx * t)^T) efficiently (Eq.
`contract_distance_vector_jacobian`(coeffs, p, dim)	Compute p^T (dt/dx) efficiently as sum(c_i * p_i) (Eqs.

Inherited from pybind11_object

Private Methods:

`_pybind11_conduit_v1_`

Inherited from FaceVertexCandidate

`_pybind11_conduit_v1_`

Inherited from TangentialCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__annotations__ = {}¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.FaceVertexTangentialCollision, collision: ipctk.FaceVertexNormalCollision) -> None
__init__(self: ipctk.FaceVertexTangentialCollision, collision: ipctk.FaceVertexNormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], normal_potential: ipc::NormalPotential) -> None

__module__ = 'ipctk'¶

_pybind11_conduit_v1_()¶