Struct VertexDerivedInteraction

pub struct VertexDerivedInteraction<A, R, I1 = (), I2 = ()> {
    pub outside_interaction: A,
    pub inside_interaction: R,
    /* private fields */
}

Derives an interaction potential from a point-like potential.

Fields

outside_interaction: A

Interaction potential used when other vertex is outside of current polygon.

inside_interaction: R

Interaction potential when vertex is inside current polygon.

Implementations

impl<A, R, I1, I2> VertexDerivedInteraction<A, R, I1, I2>

pub fn from_two_forces(attracting_force: A, repelling_force: R) -> Self

where A: Interaction<Vector2<f64>, Vector2<f64>, Vector2<f64>, I1>, R: Interaction<Vector2<f64>, Vector2<f64>, Vector2<f64>, I2>,

Constructs a new VertexDerivedInteraction from two Interaction potentials.

One serves as the inside and one for the outside interaction.

Trait Implementations

impl<A: Clone, R: Clone, I1: Clone, I2: Clone> Clone for VertexDerivedInteraction<A, R, I1, I2>

fn clone(&self) -> VertexDerivedInteraction<A, R, I1, I2>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: Debug, R: Debug, I1: Debug, I2: Debug> Debug for VertexDerivedInteraction<A, R, I1, I2>

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

Formats the value using the given formatter.

impl<'de, A, R, I1, I2> Deserialize<'de> for VertexDerivedInteraction<A, R, I1, I2>

where A: Deserialize<'de>, R: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F, S, A, R, I1, I2, D> Interaction<Matrix<F, D, Const<2>, S>, Matrix<F, D, Const<2>, S>, Matrix<F, D, Const<2>, S>, (I1, I2)> for VertexDerivedInteraction<A, R, I1, I2>

where A: Interaction<Vector2<F>, Vector2<F>, Vector2<F>, I1>, R: Interaction<Vector2<F>, Vector2<F>, Vector2<F>, I2>, D: Dim, F: Scalar + RealField + Copy, Matrix<F, D, U2, S>: Mul<F, Output = Matrix<F, D, U2, S>>, S: RawStorageMut<F, D, U2> + Storage<F, D, U2> + Clone,

fn calculate_force_between( &self, own_pos: &Matrix<F, D, U2, S>, own_vel: &Matrix<F, D, U2, S>, ext_pos: &Matrix<F, D, U2, S>, ext_vel: &Matrix<F, D, U2, S>, ext_information: &(I1, I2), ) -> Result<(Matrix<F, D, U2, S>, Matrix<F, D, U2, S>), CalcError>

Calculates the forces (velocity-derivative) on the corresponding external position given external velocity. By providing velocities, we can calculate terms that are related to friction. The function returns two forces, one acting on the current agent and the other on the external agent.

impl<A, R, I1, I2> InteractionInformation<(I1, I2)> for VertexDerivedInteraction<A, R, I1, I2>

where A: InteractionInformation<I1>, R: InteractionInformation<I2>,

fn get_interaction_information(&self) -> (I1, I2)

Get additional information of cellular properties (ie. for cell-specific interactions).

impl<A: PartialEq, R: PartialEq, I1: PartialEq, I2: PartialEq> PartialEq for VertexDerivedInteraction<A, R, I1, I2>

fn eq(&self, other: &VertexDerivedInteraction<A, R, I1, I2>) -> 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<A, R, I1, I2> Serialize for VertexDerivedInteraction<A, R, I1, I2>

where A: Serialize, R: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A, R, I1, I2> StructuralPartialEq for VertexDerivedInteraction<A, R, I1, I2>