Struct Geometry 

pub struct Geometry {
    pub elements: Vec<String>,
    pub coords: DVector<f64>,
    pub num_atoms: usize,
}

Represents a molecular geometry with atomic elements and Cartesian coordinates.

The Geometry struct stores the fundamental information about a molecular structure: the chemical elements of each atom and their 3D positions in Cartesian coordinates. It uses a flat representation where coordinates are stored as a single-dimensional vector in the order [x1, y1, z1, x2, y2, z2, …].

Coordinate System

• Units: Angstrom (Å) - standard molecular geometry unit
• Coordinate frame: Cartesian (x, y, z)
• Origin: Arbitrary (typically centered for convenience)

Storage Format

Coordinates are stored in a DVector<f64> for efficient linear algebra operations. The flat representation enables direct use with nalgebra for matrix operations commonly required in geometry optimization.

Examples

use omecp::geometry::Geometry;

// Create a water molecule geometry (coordinates in Angstrom)
let elements = vec![
    "O".to_string(),
    "H".to_string(),
    "H".to_string(),
];
let coords = vec![
    0.0, 0.0, 0.0,        // O at origin
    0.757, 0.586, 0.0,    // H1 (Angstrom)
    -0.757, 0.586, 0.0,   // H2 (Angstrom)
];

let geometry = Geometry::new(elements, coords);
assert_eq!(geometry.num_atoms, 3);

// Get coordinates of atom 0 (oxygen)
let oxygen_coords = geometry.get_atom_coords(0);
println!("Oxygen position: ({:.3}, {:.3}, {:.3}) Angstrom",
         oxygen_coords[0], oxygen_coords[1], oxygen_coords[2]);

Fields

elements: Vec<String>

Chemical element symbols for each atom in order

coords: DVector<f64>

Flattened Cartesian coordinates [x1, y1, z1, x2, y2, z2, …] in Angstrom (Å)

num_atoms: usize

Number of atoms in the molecule

Implementations

impl Geometry

pub fn new(elements: Vec<String>, coords: Vec<f64>) -> Self

Create a new Geometry from element list and coordinate vector.

Arguments

• elements - Vector of element symbols (e.g., “C”, “H”, “O”)
• coords - Flattened coordinate vector of length 3 × num_atoms

Panics

Panics if coords.len() != elements.len() * 3, ensuring data consistency.

Examples

use omecp::geometry::Geometry;

let elements = vec!["C".to_string(), "H".to_string()];
let coords = vec![0.0, 0.0, 0.0, 1.0, 0.0, 0.0];
let geometry = Geometry::new(elements, coords);

pub fn get_atom_coords(&self, atom_idx: usize) -> [f64; 3]

Get the Cartesian coordinates of a specific atom.

Arguments

• atom_idx - Zero-based index of the atom (0 = first atom)

Returns

Array of three coordinates [x, y, z] in Angstroms.

Examples

use omecp::geometry::Geometry;

let elements = vec!["O".to_string(), "H".to_string(), "H".to_string()];
let coords = vec![0.0, 0.0, 0.0, 0.757, 0.586, 0.0, -0.757, 0.586, 0.0];
let geometry = Geometry::new(elements, coords);

// Get oxygen coordinates
let o_coords = geometry.get_atom_coords(0);
assert_eq!(o_coords, [0.0, 0.0, 0.0]);

// Get first hydrogen coordinates
let h1_coords = geometry.get_atom_coords(1);
assert_eq!(h1_coords, [0.757, 0.586, 0.0]);

Trait Implementations

impl Clone for Geometry

fn clone(&self) -> Geometry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Geometry

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

Formats the value using the given formatter.

impl From<&Geometry> for SerializableGeometry

fn from(geom: &Geometry) -> Self

Converts to this type from the input type.

impl From<SerializableGeometry> for Geometry

fn from(ser_geom: SerializableGeometry) -> Self

Converts to this type from the input type.