Struct Particle 

pub struct Particle { /* private fields */ }

A struct representing a particle record in the simulation.

Implementations

impl Particle

pub fn from_data(position: Vec3, velocity: Vec3, mass: f64) -> Self

Particle constructor from position, initial velocity and mass.

pub fn get_force(&self) -> Vec3

Returns the current force of the particle.

pub fn delay_force(&mut self)

Propagates the current force to the old force. This has to be called every time step before invoking Particle::apply_force to apply new forces.

pub fn apply_force(&mut self, force: Vec3)

Applies the given force to the particle (addition). It assumes that the force was reset with Particle::delay_force in a timestep.

pub fn get_position(&self) -> Vec3

Returns the current position of the particle.

pub fn update_position(&mut self, delta_time: f64)

Calculate the updated position of the particle given a delta time step. This functionality is constant across different simulation algorithms, so it is implemented here.

pub fn get_velocity(&self) -> Vec3

Returns the current velocity of the particle.

pub fn update_velocity(&mut self, delta_time: f64)

Calculate the updated velocity of the particle given a delta time step. This functionality is constant across different simulation algorithms, so it is implemented here.

pub fn get_mass(&self) -> f64

Returns the constant mass of the particle.

pub fn position_difference(particle1: &Particle, particle2: &Particle) -> Vec3

Calculate the vector difference between two particles’ positions. Note that the order of the particles affects the sign.

• direction(a, b) == -direction(b, a).

pub fn direction(particle1: &Particle, particle2: &Particle) -> Option<Vec3>

Calculate the normalized vector difference between two particles’ positions. Note that the order of the particles affects the sign.

• If result is Some: direction(a, b) == -direction(b, a).
• If result is None: direction(a, b) == direction(b, a) == None.

pub fn distance(particle1: &Particle, particle2: &Particle) -> f64

Calculate the distance between two particles’ positions. This function is symmetric:

• distance(a, b) == distance(b, a).

pub fn mass_product(particle1: &Particle, particle2: &Particle) -> f64

Calculate the product of the masses of two particles.

Trait Implementations

impl Debug for Particle

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Particle

fn default() -> Particle

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Particle

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Particle

fn eq(&self, other: &Particle) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Particle

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Particle