Struct ApproximateShapeOverlap 

pub struct ApproximateShapeOverlap<E, A, B = A> {
    pub shape_i: A,
    pub shape_j: B,
    pub isotropic: E,
    pub resolution: PositiveReal,
}

Apply an isotropic potential evaluated at the approximate signed overlap distance.

Use ApproximateShapeOverlap combined with OverlapPenalty and QuickInsert to quickly insert new bodies into the microstate or QuickCompress to quickly compress the system to a target density. In both cases, ApproximateShapeOverlap will allow partial overlaps that can be resolved by later trial moves.

ApproximateShapeOverlap approximates the distance r that shape j must be moved to remove any overlaps. If the shapes are already separate, r is 0. Then it returns isotropic.energy(-r). resolution sets the steps between r values.

The overlap distance is approximate and expensive to evaluate. Do not use this potential for equilibration or sampling. It is suitable only for use during a brief initialization phase when QuickInsert is adding bodies or QuickCompress is compressing the system.

Example

use hoomd_geometry::{Convex, shape::ConvexPolygon};
use hoomd_interaction::{
    pairwise::ApproximateShapeOverlap, univariate::OverlapPenalty,
};

let approximate_shape_overlap = ApproximateShapeOverlap::new(
    Convex(ConvexPolygon::regular(6)),
    OverlapPenalty::default(),
    0.01.try_into()?,
);

Fields

shape_i: A

The site i’s shape.

shape_j: B

The site j’s shape.

isotropic: E

Potential to apply as a function of the signed distance between shapes.

resolution: PositiveReal

Resolve the separation distance in multiples of this resolution.

Implementations

impl<E, G> ApproximateShapeOverlap<E, G>

pub fn new(shape: G, isotropic: E, resolution: PositiveReal) -> Self

where G: Clone,

Construct a new approximate shape overlap potential.

new() sets both shape_i and shape_j to shape. Use struct initialization syntax when you need to set these separately.

Example

use hoomd_geometry::{Convex, shape::ConvexPolygon};
use hoomd_interaction::{
    pairwise::ApproximateShapeOverlap, univariate::OverlapPenalty,
};

let approximate_shape_overlap = ApproximateShapeOverlap::new(
    Convex(ConvexPolygon::regular(6)),
    OverlapPenalty::default(),
    0.01.try_into()?,
);

Trait Implementations

impl<E, A, B, V, R> AnisotropicEnergy<V, R> for ApproximateShapeOverlap<E, A, B>

where E: UnivariateEnergy, V: InnerProduct, R: Rotation + Rotate<V>, A: IntersectsAt<B, V, R>,

fn energy(&self, r_ij: &V, o_ij: &R) -> f64

Evaluate the energy contribution from a pair of sites.

use hoomd_geometry::{Convex, shape::ConvexPolygon};
use hoomd_interaction::{
    SitePairEnergy,
    pairwise::{Anisotropic, ApproximateShapeOverlap},
    univariate::OverlapPenalty,
};
use hoomd_microstate::property::OrientedPoint;
use hoomd_vector::{Angle, Cartesian};

let approximate_shape_overlap = Anisotropic {
    interaction: ApproximateShapeOverlap::new(
        Convex(ConvexPolygon::regular(6)),
        OverlapPenalty::default(),
        0.01.try_into()?,
    ),
    r_cut: 1.0,
};

let a = OrientedPoint {
    position: Cartesian::from([0.0, 0.0]),
    orientation: Angle::default(),
};
let b = OrientedPoint {
    position: Cartesian::from([0.6, 0.0]),
    orientation: Angle::default(),
};

let energy = approximate_shape_overlap.site_pair_energy(&a, &b);
assert!(energy >= 100.0);

let c = OrientedPoint {
    position: Cartesian::from([0.9, 0.0]),
    orientation: Angle::default(),
};

let energy = approximate_shape_overlap.site_pair_energy(&a, &c);
assert!(energy >= 0.0);
assert!(energy < f64::INFINITY);

let d = OrientedPoint {
    position: Cartesian::from([1.0, 0.0]),
    orientation: Angle::default(),
};

let energy = approximate_shape_overlap.site_pair_energy(&a, &d);
assert_eq!(energy, 0.0);

impl<E: Clone, A: Clone, B: Clone> Clone for ApproximateShapeOverlap<E, A, B>

fn clone(&self) -> ApproximateShapeOverlap<E, A, B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug, A: Debug, B: Debug> Debug for ApproximateShapeOverlap<E, A, B>

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

Formats the value using the given formatter.

impl<'de, E, A, B> Deserialize<'de> for ApproximateShapeOverlap<E, A, B>

where E: Deserialize<'de>, A: Deserialize<'de>, B: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E: PartialEq, A: PartialEq, B: PartialEq> PartialEq for ApproximateShapeOverlap<E, A, B>

fn eq(&self, other: &ApproximateShapeOverlap<E, A, B>) -> 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<E, A, B> Serialize for ApproximateShapeOverlap<E, A, B>

where E: Serialize, A: Serialize, B: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<E, A, B> StructuralPartialEq for ApproximateShapeOverlap<E, A, B>