Struct nphysics3d::object::FEMVolume

pub struct FEMVolume<N: RealField + Copy> { /* fields omitted */ }

A deformable volume using FEM to simulate linear elasticity.

The volume is described by a set of tetrahedral elements. This implements an isoparametric approach where the interpolations are linear.

Implementations

impl<N: RealField + Copy> FEMVolume<N>

pub fn new(
    vertices: &[Point3<N>],
    tetrahedrons: &[Point4<usize>],
    pos: &Isometry3<N>,
    scale: &Vector3<N>,
    density: N,
    young_modulus: N,
    poisson_ratio: N,
    damping_coeffs: (N, N)
) -> Self

Initializes a new deformable volume from its tetrahedral elements.

pub fn user_data(&self) -> Option<&(dyn Any + Send + Sync)>

Retrieves a reference to the user-defined user-data attached to this object.

pub fn user_data_mut(&mut self) -> Option<&mut (dyn Any + Send + Sync)>

Retrieves a mutable reference to the user-defined user-data attached to this object.

pub fn set_user_data(
    &mut self,
    data: Option<Box<dyn Any + Send + Sync>>
) -> Option<Box<dyn Any + Send + Sync>>

Sets the user-defined data attached to this object.

pub fn take_user_data(&mut self) -> Option<Box<dyn Any + Send + Sync>>

Replace by None the user-defined data attached to this object and returns the old value.

pub fn positions(&self) -> &DVector<N>

The position of this body in generalized coordinates.

pub fn positions_mut(&mut self) -> &mut DVector<N>

The position of this body in generalized coordinates.

pub fn velocities(&self) -> &DVector<N>

The velocity of this body in generalized coordinates.

pub fn velocities_mut(&mut self) -> &mut DVector<N>

The mutable velocity of this body in generalized coordinates.

pub fn set_plasticity(&mut self, strain_threshold: N, creep: N, max_force: N)

Sets the plastic properties of this deformable volume.

Note that large plasticity creep coefficient can yield to significant instability.

pub fn set_young_modulus(&mut self, young_modulus: N)

Sets the young modulus of this deformable surface.

pub fn set_poisson_ratio(&mut self, poisson_ratio: N)

Sets the poisson ratio of this deformable surface.

pub fn boundary(&self) -> Vec<(Point3<usize>, usize)>

Returns the triangles at the boundary of this volume.

Each element of the returned Vec is a tuple containing the 3 indices of the triangle vertices, and the index of the corresponding tetrahedral element.

pub fn boundary_mesh(&self) -> (TriMesh<N>, Vec<usize>, Vec<usize>)

Returns a triangle mesh at the boundary of this volume as well as a mapping between the mesh vertices and this volume degrees of freedom and the mapping between the mesh triangles and this volume body parts (the tetrahedral elements).

The output is (triangle mesh, deformation indices, element to body part map).

pub fn boundary_collider_desc(&mut self) -> DeformableColliderDesc<N>

Computes the DeformableColliderDesc that can generate a collider covering the boundary surface of this FEM volume.

As a side-effect, this will rearrange the degrees-of-freedom (DOF) of this FEM surface so that all the DOFs linked to the boundary collider are located at the beginning of the array of DOFs of this surface.

pub fn renumber_dofs(&mut self, deformation_indices: &[usize])

Renumber degrees of freedom so that the deformation_indices[i]-th DOF becomes the i-th one.

pub fn cube(
    pos: &Isometry3<N>,
    extents: &Vector3<N>,
    nx: usize,
    ny: usize,
    nz: usize,
    density: N,
    young_modulus: N,
    poisson_ratio: N,
    damping_coeffs: (N, N)
) -> Self

Constructs an axis-aligned cube with regular subdivisions along each axis.

The cube is subdivided nx (resp. ny and nz) times along the x (resp. y and z) axis.

pub fn set_node_kinematic(&mut self, i: usize, is_kinematic: bool)

Restrict the specified node acceleration to always be zero so it can be controlled manually by the user at the velocity level.

pub fn clear_kinematic_nodes(&mut self)

Mark all nodes as non-kinematic.

Trait Implementations

impl<N: RealField + Copy> Body<N> for FEMVolume<N>

fn update_dynamics(&mut self, dt: N)

Update the dynamics property of this deformable volume.

fn gravity_enabled(&self) -> bool

Whether this body is affected by gravity.

fn enable_gravity(&mut self, enabled: bool)

Enable or disable gravity for this body.

fn deformed_positions(&self) -> Option<(DeformationsType, &[N])>

If this is a deformable body, returns its deformed positions.

fn deformed_positions_mut(&mut self) -> Option<(DeformationsType, &mut [N])>

If this is a deformable body, returns a mutable reference to its deformed positions.

fn update_kinematics(&mut self)

Updates the kinematics, e.g., positions and jacobians, of this body.

fn update_acceleration(
    &mut self,
    gravity: &Vector3<N>,
    parameters: &IntegrationParameters<N>
)

Update the acceleration of this body given the forces it is subject to and the gravity.

fn clear_forces(&mut self)

Reset the timestep-specific dynamic information of this body.

fn clear_update_flags(&mut self)

Clear all the update flags of this body.

fn update_status(&self) -> BodyUpdateStatus

The flags tracking what modifications were applied to a body.

fn apply_displacement(&mut self, disp: &[N])

Applies a generalized displacement to this body.

fn status(&self) -> BodyStatus

The status of this body.

fn set_status(&mut self, status: BodyStatus)

Set the status of this body.

fn activation_status(&self) -> &ActivationStatus<N>

Information regarding activation and deactivation (sleeping) of this body.

fn ndofs(&self) -> usize

The number of degrees of freedom of this body.

fn generalized_acceleration(&self) -> DVectorSlice<'_, N>

The generalized accelerations at each degree of freedom of this body.

fn generalized_velocity(&self) -> DVectorSlice<'_, N>

The generalized velocities of this body.

fn companion_id(&self) -> usize

The companion ID of this body.

fn set_companion_id(&mut self, id: usize)

Set the companion ID of this body (may be reinitialized by nphysics).

fn generalized_velocity_mut(&mut self) -> DVectorSliceMut<'_, N>

The mutable generalized velocities of this body.

fn integrate(&mut self, parameters: &IntegrationParameters<N>)

Integrate the position of this body.

fn activate_with_energy(&mut self, energy: N)

Force the activation of this body with the given level of energy.

fn deactivate(&mut self)

Put this body to sleep.

fn set_deactivation_threshold(&mut self, threshold: Option<N>)

Sets the energy bellow which this body is put to sleep.

fn num_parts(&self) -> usize

The number of parts of this body.

fn part(&self, id: usize) -> Option<&dyn BodyPart<N>>

A reference to the specified body part.

fn world_point_at_material_point(
    &self,
    part: &dyn BodyPart<N>,
    point: &Point3<N>
) -> Point3<N>

Transform the given point expressed in material coordinates to world-space.

fn position_at_material_point(
    &self,
    part: &dyn BodyPart<N>,
    point: &Point3<N>
) -> Isometry3<N>

Transform the given point expressed in material coordinates to world-space.

fn material_point_at_world_point(
    &self,
    part: &dyn BodyPart<N>,
    point: &Point3<N>
) -> Point3<N>

Transform the given point expressed in material coordinates to world-space.

fn fill_constraint_geometry(
    &self,
    part: &dyn BodyPart<N>,
    _: usize,
    center: &Point3<N>,
    force_dir: &ForceDirection<N>,
    j_id: usize,
    wj_id: usize,
    jacobians: &mut [N],
    inv_r: &mut N,
    ext_vels: Option<&DVectorSlice<'_, N>>,
    out_vel: Option<&mut N>
)

Fills all the jacobians (and the jacobians multiplied by the inverse augmented mass matrix) for a constraint applying a force at the point center (relative to the body part’s center of mass) and the direction dir.

fn has_active_internal_constraints(&mut self) -> bool

Returns true if this bodies contains internal constraints that need to be solved.

fn setup_internal_velocity_constraints(
    &mut self,
    _: &DVectorSlice<'_, N>,
    _: &IntegrationParameters<N>
)

Initializes the internal velocity constraints of a body.

fn warmstart_internal_velocity_constraints(
    &mut self,
    _: &mut DVectorSliceMut<'_, N>
)

For warmstarting the solver, modifies the delta velocity applied by the internal constraints of this body.

fn step_solve_internal_velocity_constraints(
    &mut self,
    _: &mut DVectorSliceMut<'_, N>
)

Execute one step for the iterative resolution of this body’s internal velocity constraints.

fn step_solve_internal_position_constraints(
    &mut self,
    _: &IntegrationParameters<N>
)

Execute one step for the iterative resolution of this body’s internal position constraints.

fn velocity_at_point(&self, part_id: usize, point: &Point3<N>) -> Velocity<N>

Gets the velocity of the given point of this body.

fn apply_force_at_local_point(
    &mut self,
    part_id: usize,
    force: &Vector3<N>,
    point: &Point3<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a force at a given local point of a part of this body.

fn apply_force(
    &mut self,
    part_id: usize,
    force: &Force<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a force at the center of mass of a part of this body.

fn apply_local_force(
    &mut self,
    part_id: usize,
    force: &Force<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a local force at the center of mass of a part of this body.

fn apply_force_at_point(
    &mut self,
    part_id: usize,
    force: &Vector3<N>,
    point: &Point3<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a force at a given point of a part of this body.

fn apply_local_force_at_point(
    &mut self,
    part_id: usize,
    force: &Vector3<N>,
    point: &Point3<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a local force at a given point of a part of this body.

fn apply_local_force_at_local_point(
    &mut self,
    part_id: usize,
    force: &Vector3<N>,
    point: &Point3<N>,
    force_type: ForceType,
    auto_wake_up: bool
)

Apply a local force at a given local point of a part of this body.

fn is_ground(&self) -> bool

Returns true if this body is the ground.

fn update_activation_status(&mut self)

Update whether this body needs to be waken up after a user-interaction.

fn advance(&mut self, _time_ratio: N)

fn validate_advancement(&mut self)

fn clamp_advancement(&mut self)

fn part_motion(
    &self,
    _part_id: usize,
    _time_origin: N
) -> Option<BodyPartMotion<N>>

fn step_started(&mut self)

fn add_local_inertia_and_com(
    &mut self,
    _part_index: usize,
    _com: Point<N>,
    _inertia: Inertia<N>
)

Add the given inertia to the local inertia of this body part.

fn status_dependent_ndofs(&self) -> usize

The number of degrees of freedom (DOF) of this body, taking its status into account.

fn status_dependent_body_part_velocity(
    &self,
    part: &dyn BodyPart<N>
) -> Velocity<N>

The velocity of the specified body part, taking this body status into account.

fn is_active(&self) -> bool

Check if this body is active.

fn is_dynamic(&self) -> bool

Whether or not the status of this body is dynamic.

fn is_kinematic(&self) -> bool

Whether or not the status of this body is kinematic.

fn is_static(&self) -> bool

Whether or not the status of this body is static.

fn activate(&mut self)

Force the activation of this body.