Struct OverlapPenalty 

pub struct OverlapPenalty {
    pub k: f64,
    pub maximum_allowed_overlap: f64,
    pub epsilon_shoulder: f64,
}

Monotonically non-decreasing potential to push sites apart (not differentiable).

OverlapPenalty is specifically designed to work with the QuickInsert and QuickCompress algorithms to quickly prepare states with non-overlapping particles. Combine it with ApproximateShapeOverlap to compute an energy that penalizes hard particle overlaps.

The potential has three regions:

U(r) = \begin{cases}
\infty & r < -d_\mathrm{max} \\
\frac{1}{2} kr^2 + \varepsilon_\mathrm{shoulder} & r < 0 \\
0 & r \ge 0
\end{cases}

The first region describes a completely hard interaction when sites overlap too far. This prevents QuickInsert from creating too much strain with an insertion. The second part applies a harmonic potential that allows trial moves to gradually resolve overlaps. In the third region, sites are allowed to move freely when not overlapping. The shoulder potential prevents trial moves from creating new overlaps.

Example

use hoomd_interaction::univariate::OverlapPenalty;

let overlap_penalty = OverlapPenalty::default();

Fields

k: f64

Spring stiffness $[\mathrm{energy}] [\mathrm{length}]^{-2}$.

maximum_allowed_overlap: f64

The largest overlap distance to allow $[\mathrm{length}]$.

epsilon_shoulder: f64

Height of the potential as $r$ approaches 0 from the left $[\mathrm{energy}]$

Implementations

impl OverlapPenalty

pub fn scaled_default(diameter: f64) -> Self

Default overlap penalty parameters for a given diameter.

Construct an OverlapPenalty with default parameters scaled to suit a site with the given diameter.

Example

use hoomd_interaction::univariate::OverlapPenalty;

let overlap_penalty = OverlapPenalty::scaled_default(2.0);

assert_eq!(overlap_penalty.maximum_allowed_overlap, 0.4);

Trait Implementations

impl Clone for OverlapPenalty

fn clone(&self) -> OverlapPenalty

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OverlapPenalty

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

Formats the value using the given formatter.

impl Default for OverlapPenalty

fn default() -> Self

Default overlap penalty parameters.

The default values are tuned for use with QuickInsert and QuickCompress applied to systems of spherical particles with diameter approximately 1.

• $k = 10,000$
• $d_\mathrm{max} = 0.2$
• $\varepsilon_\mathrm{shoulder} = 100$

Call OverlapPenalty::scaled_default to initialize with values scaled for use with non-unit diameter sites.

Example

use hoomd_interaction::univariate::OverlapPenalty;

let overlap_penalty = OverlapPenalty::default();

impl<'de> Deserialize<'de> for OverlapPenalty

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OverlapPenalty

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

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 OverlapPenalty

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

Compute the energy as a function of one variable.

impl StructuralPartialEq for OverlapPenalty