Struct Cylinder 

pub struct Cylinder {
    pub radius: PositiveReal,
    pub height: PositiveReal,
}

A circle with normal [0 0 1] swept by h/2 in the +z and -z directions.

Example

Cylinder implements the Volume trait, which is equivalent to $\pi r^2 h$.

use hoomd_geometry::{Volume, shape::Cylinder};
use std::f64::consts::PI;

let cyl = Cylinder {
    radius: 2.0.try_into()?,
    height: 3.0.try_into()?,
};
assert_eq!(cyl.volume(), PI * (2.0 * 2.0) * 3.0);

Fields

radius: PositiveReal

Radius of the Cylinder

height: PositiveReal

Height of the Cylinder

Implementations

impl Cylinder

pub fn intersects_at_infinite( &self, other: &Self, v_ij: &Cartesian<3>, o_ij: &Versor, ) -> bool

Determine whether two cylinders would intersect if they both had infinite length.

This implementation is based on Collision detection of cylindrical rigid bodies for motion planning, and provides a useful alternative to bounding sphere-based checks when the underlying bodies are highly elongated.

Example

This example is based on the scenario of two highly anisotropic shapes, whose bounding spheres have a large amount of volume relative to a tighter fitting bounding shape. Note that the effective volume checked for the infinite bounding cylinder is actually the intersection of that cylinder and the ball queried in the neighbor list, so it is guaranteed to be finite.

// Two parallel cylinders that wrap a dipyramid of height:width ratio 5:1.
let c1 = Cylinder {
    radius: 1.0.try_into().unwrap(),
    height: 10.0.try_into().unwrap(),
};
let c2 = Cylinder {
    radius: 1.0.try_into().unwrap(),
    height: 10.0.try_into().unwrap(),
};
let o_ij = Versor::default();

// Case 1: Bounding spheres would intersect, but the bounding cylinders do not.
let v_ij_no_intersect = Cartesian::from([2.1, 0.0, 0.0]);
assert!(!c1.intersects_at_infinite(&c2, &v_ij_no_intersect, &o_ij));

// Case 2: Infinite cylinders intersect, meaning we need to further check the
// underlying shapes for collision.
let v_ij_intersect = Cartesian::from([1.9, 0.0, 0.0]);
assert!(c1.intersects_at_infinite(&c2, &v_ij_intersect, &o_ij));

Trait Implementations

impl Clone for Cylinder

fn clone(&self) -> Cylinder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Cylinder

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Cylinder

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Cylinder

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Volume for Cylinder

fn volume(&self) -> f64

The N-hypervolume of a geometry.

impl StructuralPartialEq for Cylinder