Struct HarmonicRepulsion 

pub struct HarmonicRepulsion {
    pub a: f64,
    pub r_cut: f64,
}

Repulsive half of a quadratic potential well.

HarmonicRepulsion is the conservative part of the dissipative particle dynamics soft potential. The parameter a controls the strength of the potential and r_cut sets the distance at which the energy goes to 0.

The potential produce the radially repulsive force between particles as:

F(r) = \begin{cases}
-\frac{A}{r_\mathrm{cut}} \left( r - r_\mathrm{cut}\right) & r < r_\mathrm{cut} \\

0 & r \ge r_\mathrm{cut}
\end{cases}

resulting from the potential energy:

U(r) = \begin{cases}
\frac{1}{2} \frac{A}{r_\mathrm{cut}} \left(r - r_\mathrm{cut}\right)^2 & r \lt r_\mathrm{cut} \\

0 & r \ge r_\mathrm{cut}
\end{cases}

This potential forms the left half of a harmonic well centered at $r = r_\mathrm{cut}$ with a spring constant $k = \frac{A}{r_\mathrm{cut}}$.

Note that this potential has a maximum value of $A$ at $r=0$ and is therefore allows particles to completely overlap.

Examples

use approxim::{assert_abs_diff_eq, assert_relative_eq};
use hoomd_interaction::univariate::{
    HarmonicRepulsion, UnivariateEnergy, UnivariateForce,
};

let a = 1.0;
let r_cut = 1.0;

let h_repsulsion = HarmonicRepulsion { a, r_cut };
assert_abs_diff_eq!(h_repsulsion.energy(1.5), 0.0);
assert_relative_eq!(h_repsulsion.energy(0.5), 0.125);
assert_abs_diff_eq!(h_repsulsion.force(0.5), 0.5, epsilon = 1e-12);

The parameters are public fields and may be accessed directly:

use hoomd_interaction::univariate::HarmonicRepulsion;

let mut h_repulsion = HarmonicRepulsion { a: 1.0, r_cut: 1.0 };
h_repulsion.a = 5.0;
h_repulsion.r_cut = 0.75;

Fields

a: f64

Potential strength $[\mathrm{energy}] [\mathrm{length}]^{-1}$.

r_cut: f64

Distance cut-off $[\mathrm{length}]$.

Trait Implementations

impl Clone for HarmonicRepulsion

fn clone(&self) -> HarmonicRepulsion

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HarmonicRepulsion

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for HarmonicRepulsion

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for HarmonicRepulsion

fn eq(&self, other: &HarmonicRepulsion) -> 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 HarmonicRepulsion

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl UnivariateEnergy for HarmonicRepulsion

fn energy(&self, r: f64) -> f64

Compute the energy as a function of one variable.

impl UnivariateForce for HarmonicRepulsion

fn force(&self, r: f64) -> f64

Compute force as a function of one variable.

impl StructuralPartialEq for HarmonicRepulsion