Struct ConstantForce 

pub struct ConstantForce<V> {
    pub force: V,
    pub r_0: V,
}

Apply the same force to every site, independent of the site’s properties.

The field force sets the force vector $\vec{F}$. The corresponding potential energy $U$ is:

U = - \vec{F} \cdot ( \vec{r} - \vec{r}_0 )

The vector $\vec{r}_0$ sets the reference plane where $U = 0$.

Generics

• V: The type used to represent the position and force vectors.

Example

Basic usage:

use hoomd_interaction::external::ConstantForce;
use hoomd_vector::{Cartesian, Unit};

let constant_force = ConstantForce {
    force: Cartesian::from([0.0, -2.0]),
    r_0: Cartesian::from([0.0, -10.0]),
};

Fields

force: V

Force vector $[\mathrm{energy}] \cdot [\mathrm{length}]^{-1}$.

r_0: V

$\vec{r}_0$ $[\mathrm{length}]$: A point on the plane where $U = 0$.

Implementations

impl<V> ConstantForce<V>

where V: InnerProduct,

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

Compute the energy of a point in a constant force field.

Example

use hoomd_interaction::external::ConstantForce;
use hoomd_vector::Cartesian;

let constant_force = ConstantForce {
    force: Cartesian::from([0.0, -2.0]),
    r_0: Cartesian::from([0.0, -10.0]),
};

let energy = constant_force.energy(&[0.0, 0.0].into());
assert_eq!(energy, 20.0);

pub fn force(&self) -> V

The force vector that acts on all sites.

Example

use hoomd_interaction::external::ConstantForce;
use hoomd_vector::Cartesian;

let constant_force = ConstantForce {
    force: Cartesian::from([0.0, -2.0]),
    r_0: Cartesian::from([0.0, -10.0]),
};

let force = constant_force.force();
assert_eq!(force, [0.0, -2.0].into());

Trait Implementations

impl<V: Clone> Clone for ConstantForce<V>

fn clone(&self) -> ConstantForce<V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V: Debug> Debug for ConstantForce<V>

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

Formats the value using the given formatter.

impl<'de, V> Deserialize<'de> for ConstantForce<V>

where V: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<V: PartialEq> PartialEq for ConstantForce<V>

fn eq(&self, other: &ConstantForce<V>) -> 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<V> Serialize for ConstantForce<V>

where V: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S, P> SiteEnergy<S> for ConstantForce<P>

where S: Position<Position = P>, P: InnerProduct,

fn site_energy(&self, site_properties: &S) -> f64

Evaluate the energy contribution of a single site.

Example

use hoomd_interaction::{external::ConstantForce, SiteEnergy};
use hoomd_vector::Cartesian;
use hoomd_microstate::property::Point;

let constant_force = ConstantForce {
    force: Cartesian::from([0.0, -2.0]),
    r_0: Cartesian::from([0.0, -10.0]),
};

let a = Point { position: Cartesian::from([0.0, 0.0]) };
let b = Point { position: Cartesian::from([0.0, 3.0]) };

let energy_0 = constant_force.site_energy(&a);
assert_eq!(energy_0, 20.0);
let energy_1 = constant_force.site_energy(&b);
assert_eq!(energy_1, 26.0);

fn site_energy_initial(&self, site_properties: &S) -> f64

Evaluate the energy contribution of a single site in the initial state.

fn is_only_infinite_or_zero() -> bool

Does this potential only ever return infinity or zero?

impl<S, V> SiteForceAndVirial<S> for ConstantForce<V>

where V: InnerProduct + Outer, S: Position<Position = V>,

fn site_force_and_virial( &self, site_properties: &S, ) -> (Self::Force, <Self::Force as Outer>::Tensor)

Evaluate the force and virial as a function of a single site’s properties.

Example

use hoomd_interaction::{SiteForceAndVirial, external::ConstantForce};
use hoomd_linear_algebra::matrix::Matrix;
use hoomd_microstate::property::Point;
use hoomd_vector::Cartesian;

let constant_force = ConstantForce {
    force: Cartesian::from([0.0, -2.0]),
    r_0: Cartesian::from([0.0, -10.0]),
};

let a = Point {
    position: Cartesian::from([0.0, 0.0]),
};
let b = Point {
    position: Cartesian::from([0.0, 3.0]),
};

let (force_0, virial_0) = constant_force.site_force_and_virial(&a);
assert_eq!(force_0, [0.0, -2.0].into());
assert_eq!(
    virial_0,
    Matrix {
        rows: [[0.0, 0.0], [0.0, 0.0]]
    }
);

let (force_1, virial_1) = constant_force.site_force_and_virial(&b);
assert_eq!(force_1, [0.0, -2.0].into());
assert_eq!(
    virial_1,
    Matrix {
        rows: [[0.0, 0.0], [0.0, -6.0]]
    }
);

type Force = V

The type of the result force.

impl<S, V> SiteForceVirialAndTorque<S> for ConstantForce<V>

where V: InnerProduct + Wedge + Outer, V::Bivector: Default, S: Position<Position = V>,

fn site_force_virial_and_torque( &self, site_properties: &S, ) -> (V, <Self::Force as Outer>::Tensor, V::Bivector)

Evaluate the force, virial, and torque as a function of a single site’s properties.

Example

use hoomd_interaction::{
    SiteForceVirialAndTorque, external::ConstantForce,
};
use hoomd_linear_algebra::matrix::Matrix;
use hoomd_microstate::property::Point;
use hoomd_vector::Cartesian;

let constant_force = ConstantForce {
    force: Cartesian::from([0.0, -2.0]),
    r_0: Cartesian::from([0.0, -10.0]),
};

let a = Point {
    position: Cartesian::from([0.0, 0.0]),
};
let b = Point {
    position: Cartesian::from([0.0, 3.0]),
};

let (force_0, virial_0, torque_0) =
    constant_force.site_force_virial_and_torque(&a);
assert_eq!(force_0, [0.0, -2.0].into());
assert_eq!(torque_0, 0.0);
assert_eq!(
    virial_0,
    Matrix {
        rows: [[0.0, 0.0], [0.0, 0.0]]
    }
);

let (force_1, virial_1, torque_1) =
    constant_force.site_force_virial_and_torque(&b);
assert_eq!(force_1, [0.0, -2.0].into());
assert_eq!(torque_1, 0.0);
assert_eq!(
    virial_1,
    Matrix {
        rows: [[0.0, 0.0], [0.0, -6.0]]
    }
);

type Force = V

The type of the result force.

impl<V> StructuralPartialEq for ConstantForce<V>