Normal Collisions¶

class ipctk.NormalCollisions¶

Bases: pybind11_object

Public Data Attributes:

`IPC`
`IMPROVED_MAX_APPROX`
`OGC`
`use_area_weighting`	If the NormalCollisions should use the convergent formulation.
`collision_set_type`	The type of collision set to use.
`enable_shape_derivatives`	If the NormalCollisions are using the convergent formulation.
`vv_collisions`
`ev_collisions`
`ee_collisions`
`fv_collisions`
`pv_collisions`

Public Methods:

`__init__`(self)
`build`(args, *kwargs)	Overloaded function.
`compute_minimum_distance`(self, mesh, vertices)	Computes the minimum distance between any non-adjacent elements.
`__len__`(self)	Get the number of collisions.
`empty`(self)	Get if the collision set are empty.
`clear`(self)	Clear the collision set.
`__getitem__`(self, i)	Get a reference to collision at index i.
`is_vertex_vertex`(self, i)	Get if the collision at i is a vertex-vertex collision.
`is_edge_vertex`(self, i)	Get if the collision at i is an edge-vertex collision.
`is_edge_edge`(self, i)	Get if the collision at i is an edge-edge collision.
`is_face_vertex`(self, i)	Get if the collision at i is an face-vertex collision.
`is_plane_vertex`(self, i)	Get if the collision at i is an plane-vertex collision.
`__str__`(self, mesh, vertices)

Private Methods:

`_pybind11_conduit_v1_`

class CollisionSetType¶

Bases: pybind11_object

Members:

IPC : IPC set type, which uses the original formulation described in [Li et al. 2020].

IMPROVED_MAX_APPROX : Improved max approximation set type, which uses the improved max approximation formulation described in [Li et al. 2023].

OGC : Offset Geometric Contact set type, which uses the formulation described in [Chen et al. 2025].

IMPROVED_MAX_APPROX = <CollisionSetType.IMPROVED_MAX_APPROX: 1>¶

IPC = <CollisionSetType.IPC: 0>¶

OGC = <CollisionSetType.OGC: 2>¶

__eq__(self, other: object, /) → bool¶

__getstate__(self, /) → int¶

__hash__(self, /) → int¶

__index__(self, /) → int¶

__init__(self, value: SupportsInt)¶

__int__(self, /) → int¶

__members__ = {'IMPROVED_MAX_APPROX': <CollisionSetType.IMPROVED_MAX_APPROX: 1>, 'IPC': <CollisionSetType.IPC: 0>, 'OGC': <CollisionSetType.OGC: 2>}¶

__ne__(self, other: object, /) → bool¶

__repr__(self, /) → str¶

__setstate__(self, state: SupportsInt, /) → None¶

__str__(self, /) → str¶

property name : str¶

property value : int¶

IMPROVED_MAX_APPROX = <CollisionSetType.IMPROVED_MAX_APPROX: 1>¶

IPC = <CollisionSetType.IPC: 0>¶

OGC = <CollisionSetType.OGC: 2>¶

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

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 collisions.

__str__(self, mesh: ipctk.CollisionMesh, vertices: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.f_contiguous']) → str¶

build(*args, **kwargs)¶

Overloaded function.

build(self: ipctk.NormalCollisions, mesh: ipctk.CollisionMesh, vertices: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.f_contiguous”], dhat: typing.SupportsFloat, dmin: typing.SupportsFloat | None = None, broad_phase: ipctk.BroadPhase = None) -> None

Initialize the set of collisions used to compute the barrier potential.

Parameters:
mesh: The collision mesh. vertices: Vertices of the collision mesh. dhat: The activation distance of the barrier. dmin: Deprecated: give the mesh a thickness (CollisionMesh.set_thickness) instead. If given, every collision keeps this minimum distance and the mesh’s thickness is ignored; otherwise each keeps its two primitives’ thicknesses. broad_phase: Broad-phase to use.
build(self: ipctk.NormalCollisions, candidates: ipctk.Candidates, mesh: ipctk.CollisionMesh, vertices: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”, “flags.f_contiguous”], dhat: typing.SupportsFloat, dmin: typing.SupportsFloat | None = None) -> None

Initialize the set of collisions used to compute the barrier potential.

Parameters:
candidates: Distance candidates from which the collision set is built. mesh: The collision mesh. vertices: Vertices of the collision mesh. dhat: The activation distance of the barrier. dmin: Deprecated: give the mesh a thickness (CollisionMesh.set_thickness) instead. If given, every collision keeps this minimum distance and the mesh’s thickness is ignored; otherwise each keeps its two primitives’ thicknesses.

Raises:
ValueError: In 3D, if the candidates were built with all_types=True.

clear(self) → None¶: Clear the collision set.

property collision_set_type : ipctk.NormalCollisions.CollisionSetType¶

The type of collision set to use.

This can be either:

IPC (Implicit Potential Collisions)
IMPROVED_MAX_APPROX (Improved Max Approximation)
OGC (Offset Geometric Contact)

compute_minimum_distance(self, mesh: ipctk.CollisionMesh, vertices: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.f_contiguous']) → float¶

Computes the minimum distance between any non-adjacent elements.

Parameters:¶

mesh: ipctk.CollisionMesh¶: The collision mesh.
vertices: Annotated[numpy.typing.NDArray[numpy.float64], '[m, n]', 'flags.f_contiguous']¶: Vertices of the collision mesh.

Returns:¶

The minimum distance between any non-adjacent elements.

property ee_collisions : list[ipc::EdgeEdgeNormalCollision]¶

empty(self) → bool¶: Get if the collision set are empty.

property enable_shape_derivatives : bool¶: If the NormalCollisions are using the convergent formulation.

property ev_collisions : list[ipc::EdgeVertexNormalCollision]¶

property fv_collisions : list[ipc::FaceVertexNormalCollision]¶

is_edge_edge(self, i: SupportsInt) → bool¶

Get if the collision at i is an edge-edge collision.

Parameters:¶

i: SupportsInt¶: The index of the collision.

Returns:¶

If the collision at i is an edge-edge collision.

is_edge_vertex(self, i: SupportsInt) → bool¶

Get if the collision at i is an edge-vertex collision.

Parameters:¶

i: SupportsInt¶: The index of the collision.

Returns:¶

If the collision at i is an edge-vertex collision.

is_face_vertex(self, i: SupportsInt) → bool¶

Get if the collision at i is an face-vertex collision.

Parameters:¶

i: SupportsInt¶: The index of the collision.

Returns:¶

If the collision at i is an face-vertex collision.

is_plane_vertex(self, i: SupportsInt) → bool¶

Get if the collision at i is an plane-vertex collision.

Parameters:¶

i: SupportsInt¶: The index of the collision.

Returns:¶

If the collision at i is an plane-vertex collision.

is_vertex_vertex(self, i: SupportsInt) → bool¶

Get if the collision at i is a vertex-vertex collision.

Parameters:¶

i: SupportsInt¶: The index of the collision.

Returns:¶

If the collision at i is a vertex-vertex collision.

property pv_collisions : list[ipc::PlaneVertexNormalCollision]¶

property use_area_weighting : bool¶: If the NormalCollisions should use the convergent formulation.

property vv_collisions : list[ipc::VertexVertexNormalCollision]¶

Normal Collision¶

class ipctk.NormalCollision¶

Bases: CollisionStencil

Public Data Attributes:

`dmin`	The minimum separation distance.
`weight`	The term's weight (e.g., collision area)
`weight_gradient`	The gradient of the term's weight wrt the rest positions.

Public Methods:

`__init__`(args, *kwargs)
`is_mollified`(self)	Does the distance potentially have to be mollified?
`mollifier_threshold`(self, rest_positions)	Compute the mollifier threshold for the distance.
`mollifier`(args, *kwargs)	Overloaded function.
`mollifier_gradient`(args, *kwargs)	Overloaded function.
`mollifier_hessian`(args, *kwargs)	Overloaded function.
`mollifier_gradient_wrt_x`(self, ...)	Compute the gradient of the mollifier for the distance w.r.t.
`mollifier_gradient_jacobian_wrt_x`(self, ...)	Compute the jacobian of the distance mollifier's gradient w.r.t.

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.

Private Methods:

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__init__(*args, **kwargs)¶

property dmin : float¶: The minimum separation distance.

is_mollified(self) → bool¶: Does the distance potentially have to be mollified?

mollifier(*args, **kwargs)¶

Overloaded function.

mollifier(self: ipctk.NormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]) -> float

Compute the mollifier for the distance.

Parameters:
positions: The stencil’s vertex positions.

Returns:
The mollifier value.
mollifier(self: ipctk.NormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], eps_x: typing.SupportsFloat) -> float

Compute the mollifier for the distance.

Parameters:
positions: The stencil’s vertex positions. eps_x: The mollifier’s threshold.

Returns:
The mollifier value.

mollifier_gradient(*args, **kwargs)¶

Overloaded function.

mollifier_gradient(self: ipctk.NormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]

Compute the gradient of the mollifier for the distance wrt the positions.

Parameters:
positions: The stencil’s vertex positions.

Returns:
The mollifier gradient.
mollifier_gradient(self: ipctk.NormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], eps_x: typing.SupportsFloat) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]

Compute the gradient of the mollifier for the distance wrt the positions.

Parameters:
positions: The stencil’s vertex positions. eps_x: The mollifier’s threshold.

Returns:
The mollifier gradient.

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

Compute the jacobian of the distance mollifier’s gradient w.r.t. rest positions.

Parameters:¶

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

Returns:¶

The jacobian of the mollifier’s gradient w.r.t. rest positions.

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

Compute the gradient of the mollifier for the distance w.r.t. rest positions.

Parameters:¶

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

Returns:¶

The mollifier gradient w.r.t. rest positions.

mollifier_hessian(*args, **kwargs)¶

Overloaded function.

mollifier_hessian(self: ipctk.NormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”]) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

Compute the Hessian of the mollifier for the distance wrt the positions.

Parameters:
positions: The stencil’s vertex positions.

Returns:
The mollifier Hessian.
mollifier_hessian(self: ipctk.NormalCollision, positions: typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, 1]”], eps_x: typing.SupportsFloat) -> typing.Annotated[numpy.typing.NDArray[numpy.float64], “[m, n]”]

Compute the Hessian of the mollifier for the distance wrt the positions.

Parameters:
positions: The stencil’s vertex positions. eps_x: The mollifier’s threshold.

Returns:
The mollifier Hessian.

mollifier_threshold(self, rest_positions: Annotated[numpy.typing.NDArray[numpy.float64], '[m, 1]']) → float¶

Compute the mollifier threshold for the distance.

Parameters:¶

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

Returns:¶

The mollifier threshold.

property weight : float¶: The term’s weight (e.g., collision area)

property weight_gradient : scipy.sparse.csc_matrix[numpy.float64]¶: The gradient of the term’s weight wrt the rest positions.

Vertex-Vertex Normal Collision¶

class ipctk.VertexVertexNormalCollision¶

Bases: VertexVertexStencil, NormalCollision

Public Data Attributes:

Inherited from VertexVertexCandidate

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

Inherited from NormalCollision

`dmin`	The minimum separation distance.
`weight`	The term's weight (e.g., collision area)
`weight_gradient`	The gradient of the term's weight wrt the rest positions.

Public Methods:

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

Inherited from VertexVertexStencil

`__init__`(args, *kwargs)

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.
`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.
`thickness`(self, vertex_thickness, ...)	Get the sum of the two primitives' thicknesses (see CollisionMesh.set_thickness).
`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.
`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.
`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.
`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 NormalCollision

`__init__`(args, *kwargs)
`is_mollified`(self)	Does the distance potentially have to be mollified?
`mollifier_threshold`(self, rest_positions)	Compute the mollifier threshold for the distance.
`mollifier`(args, *kwargs)	Overloaded function.
`mollifier_gradient`(args, *kwargs)	Overloaded function.
`mollifier_hessian`(args, *kwargs)	Overloaded function.
`mollifier_gradient_wrt_x`(self, ...)	Compute the gradient of the mollifier for the distance w.r.t.
`mollifier_gradient_jacobian_wrt_x`(self, ...)	Compute the jacobian of the distance mollifier's gradient w.r.t.

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.

Private Methods:

`_pybind11_conduit_v1_`

Inherited from VertexVertexStencil

`_pybind11_conduit_v1_`

Inherited from VertexVertexCandidate

`_pybind11_conduit_v1_`

Inherited from NormalCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.VertexVertexNormalCollision, vertex0_id: typing.SupportsInt, vertex1_id: typing.SupportsInt) -> None
__init__(self: ipctk.VertexVertexNormalCollision, vv_candidate: ipctk.VertexVertexCandidate) -> None

Edge-Vertex Normal Collision¶

class ipctk.EdgeVertexNormalCollision¶

Bases: EdgeVertexStencil, NormalCollision

Public Data Attributes:

Inherited from EdgeVertexCandidate

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

Inherited from NormalCollision

`dmin`	The minimum separation distance.
`weight`	The term's weight (e.g., collision area)
`weight_gradient`	The gradient of the term's weight wrt the rest positions.

Public Methods:

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

Inherited from EdgeVertexStencil

`__init__`(args, *kwargs)

Inherited from EdgeVertexCandidate

`__init__`(args, *kwargs)	Overloaded function.
`known_dtype`()
`__str__`(self)
`__repr__`(self)
`__eq__`(self, other)
`__ne__`(self, other)
`__lt__`(self, other)	Compare EdgeVertexCandidates for sorting.
`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.
`thickness`(self, vertex_thickness, ...)	Get the sum of the two primitives' thicknesses (see CollisionMesh.set_thickness).
`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.
`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.
`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.
`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 NormalCollision

`__init__`(args, *kwargs)
`is_mollified`(self)	Does the distance potentially have to be mollified?
`mollifier_threshold`(self, rest_positions)	Compute the mollifier threshold for the distance.
`mollifier`(args, *kwargs)	Overloaded function.
`mollifier_gradient`(args, *kwargs)	Overloaded function.
`mollifier_hessian`(args, *kwargs)	Overloaded function.
`mollifier_gradient_wrt_x`(self, ...)	Compute the gradient of the mollifier for the distance w.r.t.
`mollifier_gradient_jacobian_wrt_x`(self, ...)	Compute the jacobian of the distance mollifier's gradient w.r.t.

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.

Private Methods:

`_pybind11_conduit_v1_`

Inherited from EdgeVertexStencil

`_pybind11_conduit_v1_`

Inherited from EdgeVertexCandidate

`_pybind11_conduit_v1_`

Inherited from NormalCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.EdgeVertexNormalCollision, edge_id: typing.SupportsInt, vertex_id: typing.SupportsInt) -> None
__init__(self: ipctk.EdgeVertexNormalCollision, candidate: ipctk.EdgeVertexCandidate) -> None

Edge-Edge Normal Collision¶

class ipctk.EdgeEdgeNormalCollision¶

Bases: EdgeEdgeStencil, NormalCollision

Public Data Attributes:

`eps_x`	Mollifier activation threshold.
`dtype`	Cached distance type.

Inherited from EdgeEdgeCandidate

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

Inherited from NormalCollision

`dmin`	The minimum separation distance.
`weight`	The term's weight (e.g., collision area)
`weight_gradient`	The gradient of the term's weight wrt the rest positions.

Public Methods:

`__init__`(args, *kwargs)	Overloaded function.
`__eq__`(self, other)
`__ne__`(self, other)
`__lt__`(self, other)

Inherited from EdgeEdgeStencil

`__init__`(args, *kwargs)

Inherited from EdgeEdgeCandidate

`__init__`(args, *kwargs)	Overloaded function.
`known_dtype`()
`__str__`(self)
`__repr__`(self)
`__eq__`(self, other)
`__ne__`(self, other)
`__lt__`(self, other)	Compare EdgeEdgeCandidates for sorting.
`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.
`thickness`(self, vertex_thickness, ...)	Get the sum of the two primitives' thicknesses (see CollisionMesh.set_thickness).
`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.
`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.
`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.
`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 NormalCollision

`__init__`(args, *kwargs)
`is_mollified`(self)	Does the distance potentially have to be mollified?
`mollifier_threshold`(self, rest_positions)	Compute the mollifier threshold for the distance.
`mollifier`(args, *kwargs)	Overloaded function.
`mollifier_gradient`(args, *kwargs)	Overloaded function.
`mollifier_hessian`(args, *kwargs)	Overloaded function.
`mollifier_gradient_wrt_x`(self, ...)	Compute the gradient of the mollifier for the distance w.r.t.
`mollifier_gradient_jacobian_wrt_x`(self, ...)	Compute the jacobian of the distance mollifier's gradient w.r.t.

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.

Private Methods:

`_pybind11_conduit_v1_`

Inherited from EdgeEdgeStencil

`_pybind11_conduit_v1_`

Inherited from EdgeEdgeCandidate

`_pybind11_conduit_v1_`

Inherited from NormalCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__eq__(self, other: ipctk.EdgeEdgeNormalCollision) → bool¶

__hash__ = None¶

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.EdgeEdgeNormalCollision, edge0_id: typing.SupportsInt, edge1_id: typing.SupportsInt, eps_x: typing.SupportsFloat, dtype: ipctk.EdgeEdgeDistanceType = <EdgeEdgeDistanceType.AUTO: 9>) -> None
__init__(self: ipctk.EdgeEdgeNormalCollision, candidate: ipctk.EdgeEdgeCandidate, eps_x: typing.SupportsFloat, dtype: ipctk.EdgeEdgeDistanceType = <EdgeEdgeDistanceType.AUTO: 9>) -> None

__lt__(self, other: ipctk.EdgeEdgeNormalCollision) → bool¶

__ne__(self, other: ipctk.EdgeEdgeNormalCollision) → bool¶

property dtype : ipctk.EdgeEdgeDistanceType¶

Cached distance type.

Some EE collisions are mollified EV or VV collisions.

property eps_x : float¶: Mollifier activation threshold.

Face-Vertex Normal Collision¶

class ipctk.FaceVertexNormalCollision¶

Bases: FaceVertexStencil, NormalCollision

Public Data Attributes:

Inherited from FaceVertexCandidate

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

Inherited from NormalCollision

`dmin`	The minimum separation distance.
`weight`	The term's weight (e.g., collision area)
`weight_gradient`	The gradient of the term's weight wrt the rest positions.

Public Methods:

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

Inherited from FaceVertexStencil

`__init__`(args, *kwargs)

Inherited from FaceVertexCandidate

`__init__`(args, *kwargs)	Overloaded function.
`known_dtype`()
`__str__`(self)
`__repr__`(self)
`__eq__`(self, other)
`__ne__`(self, other)
`__lt__`(self, other)	Compare FaceVertexCandidate for sorting.
`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.
`thickness`(self, vertex_thickness, ...)	Get the sum of the two primitives' thicknesses (see CollisionMesh.set_thickness).
`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.
`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.
`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.
`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 NormalCollision

`__init__`(args, *kwargs)
`is_mollified`(self)	Does the distance potentially have to be mollified?
`mollifier_threshold`(self, rest_positions)	Compute the mollifier threshold for the distance.
`mollifier`(args, *kwargs)	Overloaded function.
`mollifier_gradient`(args, *kwargs)	Overloaded function.
`mollifier_hessian`(args, *kwargs)	Overloaded function.
`mollifier_gradient_wrt_x`(self, ...)	Compute the gradient of the mollifier for the distance w.r.t.
`mollifier_gradient_jacobian_wrt_x`(self, ...)	Compute the jacobian of the distance mollifier's gradient w.r.t.

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.

Private Methods:

`_pybind11_conduit_v1_`

Inherited from FaceVertexStencil

`_pybind11_conduit_v1_`

Inherited from FaceVertexCandidate

`_pybind11_conduit_v1_`

Inherited from NormalCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: ipctk.FaceVertexNormalCollision, face_id: typing.SupportsInt, vertex_id: typing.SupportsInt) -> None
__init__(self: ipctk.FaceVertexNormalCollision, candidate: ipctk.FaceVertexCandidate) -> None

Plane-Vertex Normal Collision¶

class ipctk.PlaneVertexNormalCollision¶

Bases: PlaneVertexStencil, NormalCollision

Public Data Attributes:

Inherited from PlaneVertexCandidate

`plane`	Plane of the candidate
`vertex_id`	ID of the vertex

Inherited from NormalCollision

`dmin`	The minimum separation distance.
`weight`	The term's weight (e.g., collision area)
`weight_gradient`	The gradient of the term's weight wrt the rest positions.

Public Methods:

`__init__`(self, plane, vertex_id)

Inherited from PlaneVertexStencil

`__init__`(args, *kwargs)

Inherited from PlaneVertexCandidate

`__init__`(self, plane, vertex_id)
`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.
`thickness`(self, vertex_thickness, ...)	Get the sum of the two primitives' thicknesses (see CollisionMesh.set_thickness).
`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.
`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.
`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.
`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 NormalCollision

`__init__`(args, *kwargs)
`is_mollified`(self)	Does the distance potentially have to be mollified?
`mollifier_threshold`(self, rest_positions)	Compute the mollifier threshold for the distance.
`mollifier`(args, *kwargs)	Overloaded function.
`mollifier_gradient`(args, *kwargs)	Overloaded function.
`mollifier_hessian`(args, *kwargs)	Overloaded function.
`mollifier_gradient_wrt_x`(self, ...)	Compute the gradient of the mollifier for the distance w.r.t.
`mollifier_gradient_jacobian_wrt_x`(self, ...)	Compute the jacobian of the distance mollifier's gradient w.r.t.

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.

Private Methods:

`_pybind11_conduit_v1_`

Inherited from PlaneVertexStencil

`_pybind11_conduit_v1_`

Inherited from PlaneVertexCandidate

`_pybind11_conduit_v1_`

Inherited from NormalCollision

`_pybind11_conduit_v1_`

Inherited from CollisionStencil

`_pybind11_conduit_v1_`

__init__(self, plane: ipctk.Hyperplane, vertex_id: SupportsInt)¶