Struct Harm 

pub struct Harm<T> { /* private fields */ }

Harmonic torsion potential (restraint).

Parameters

• k: Force constant (energy/radian² units)
• phi0: Equilibrium dihedral angle (radians)

Precomputed Values

• two_k: Stores 2*k for efficient derivative computation
• cos_phi0, sin_phi0: Precomputed for angle-difference formula

Implementations

impl<T: Vector> Harm<T>

pub fn new(k: f64, phi0: f64) -> Self

Creates a new harmonic torsion potential.

Arguments

• k: Force constant [energy/radian²]
• phi0: Equilibrium angle (radians)

Example

use potentials::torsion::Harm;
use core::f64::consts::PI;

// Restrain to trans configuration (180°)
let restraint = Harm::<f64>::new(100.0, PI);

pub fn cis(k: f64) -> Self

Creates with equilibrium at cis (phi0 = 0).

pub fn trans(k: f64) -> Self

Creates with equilibrium at trans (phi0 = pi).

Trait Implementations

impl<T: Clone> Clone for Harm<T>

fn clone(&self) -> Harm<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Harm<T>

impl<T: Debug> Debug for Harm<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Harm<T>

fn eq(&self, other: &Harm<T>) -> 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<T: Vector> Potential4<T> for Harm<T>

fn energy(&self, cos_phi: T, sin_phi: T) -> T

Computes the potential energy.

Uses the angle difference formula to compute (phi - phi0) from cos and sin values without explicitly computing atan2.

delta_phi = atan2(sin(phi - phi0), cos(phi - phi0))
          = atan2(sin_phi*cos_phi0 - cos_phi*sin_phi0,
                  cos_phi*cos_phi0 + sin_phi*sin_phi0)
V = k * delta_phi^2

fn derivative(&self, cos_phi: T, sin_phi: T) -> T

Computes dV/d(phi).

dV/d(phi) = 2k * (phi - phi0)

fn energy_derivative(&self, cos_phi: T, sin_phi: T) -> (T, T)

Computes energy and derivative together (optimized).

Shares the computation of sin_delta, cos_delta, and delta_phi.

impl<T: PartialEq> StructuralPartialEq for Harm<T>