Struct LennardJones 

pub struct LennardJones<const N: i32 = 12, const M: i32 = 6> {
    pub epsilon: f64,
    pub sigma: f64,
}

Potential with a steep repulsive core and an attractive well.

U(r) = 4 \varepsilon \left[ \left( \frac{\sigma}{r} \right)^{N} - \left( \frac{\sigma}{r} \right)^{M} \right]

Compute the Lennard-Jones (LJ) potential and force as a function of r.

Examples

In basic usage, the exponents N and M default to 12 and 6, respectively:

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

let epsilon = 1.5;
let sigma = 2.5;

let lennard_jones: LennardJones = LennardJones { epsilon, sigma };
assert_abs_diff_eq!(lennard_jones.energy(sigma), 0.0);
assert_relative_eq!(
    lennard_jones.energy(2.0_f64.powf(1.0 / 6.0) * sigma),
    -epsilon
);
assert_abs_diff_eq!(
    lennard_jones.force(2.0_f64.powf(1.0 / 6.0) * sigma),
    0.0,
    epsilon = 1e-12
);

You can choose any values for N and M at compile time:

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

let epsilon = 1.5;
let sigma = 2.5;

let lennard_jones: LennardJones<8, 4> = LennardJones { epsilon, sigma };
assert_abs_diff_eq!(lennard_jones.energy(sigma), 0.0);
assert_relative_eq!(
    lennard_jones.energy(2.0_f64.powf(1.0 / 4.0) * sigma),
    -epsilon,
    epsilon = 1e-12
);
assert_abs_diff_eq!(
    lennard_jones.force(2.0_f64.powf(1.0 / 4.0) * sigma),
    0.0,
    epsilon = 1e-12
);

The parameters are public fields and may be accessed directly:

use hoomd_interaction::univariate::LennardJones;

let mut lennard_jones: LennardJones = LennardJones::default();
lennard_jones.epsilon = 1.5;
lennard_jones.sigma = 3.0;

Fields

epsilon: f64

Energy scale ([energy]).

sigma: f64

Interaction width ([length]).

Trait Implementations

impl<const N: i32, const M: i32> Clone for LennardJones<N, M>

fn clone(&self) -> LennardJones<N, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: i32, const M: i32> Debug for LennardJones<N, M>

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

Formats the value using the given formatter.

impl<const N: i32, const M: i32> Default for LennardJones<N, M>

fn default() -> Self

Construct a LennardJones with default parameters (epsilon=1.0, sigma=1.0)

Example

use hoomd_interaction::univariate::LennardJones;

let lennard_jones: LennardJones = LennardJones::default();

impl<'de, const N: i32, const M: i32> Deserialize<'de> for LennardJones<N, M>

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: i32, const M: i32> PartialEq for LennardJones<N, M>

fn eq(&self, other: &LennardJones<N, M>) -> 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<const N: i32, const M: i32> Serialize for LennardJones<N, M>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: i32, const M: i32> UnivariateEnergy for LennardJones<N, M>

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

Compute the energy as a function of one variable.

impl<const N: i32, const M: i32> UnivariateForce for LennardJones<N, M>

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

Compute force as a function of one variable.

impl<const N: i32, const M: i32> StructuralPartialEq for LennardJones<N, M>