moyo 0.10.0

Library for Crystal Symmetry in Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use nalgebra::{Matrix3, Vector3};
use serde::Serialize;
use strum_macros::EnumIter;

use crate::base::{Linear, Translation};

/// Centering type for layer groups (only oblique-/rectangular-primitive and
/// rectangular-centered exist in 2D).
#[derive(Debug, Copy, Clone, PartialEq, EnumIter, Serialize)]
pub enum LayerCentering {
    P, // Primitive
    C, // C-face centered (in-plane only)
}

impl LayerCentering {
    pub fn order(&self) -> usize {
        match self {
            LayerCentering::P => 1,
            LayerCentering::C => 2,
        }
    }

    /// Transformation matrix from primitive to conventional cell.
    /// The c (aperiodic) axis is left untouched.
    pub fn linear(&self) -> Linear {
        match self {
            LayerCentering::P => Linear::identity(),
            LayerCentering::C => Linear::new(
                1, -1, 0, //
                1, 1, 0, //
                0, 0, 1, //
            ),
        }
    }

    /// Transformation matrix from conventional to primitive cell.
    pub fn inverse(&self) -> Matrix3<f64> {
        self.linear().map(|e| e as f64).try_inverse().unwrap()
    }

    /// Lattice points of the conventional cell expressed in the conventional basis.
    /// Centerings are 2D-only: the c-component is always zero.
    pub fn lattice_points(&self) -> Vec<Vector3<f64>> {
        match self {
            LayerCentering::P => {
                vec![Translation::new(0.0, 0.0, 0.0)]
            }
            LayerCentering::C => {
                vec![
                    Translation::new(0.0, 0.0, 0.0),
                    Translation::new(0.5, 0.5, 0.0),
                ]
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use strum::IntoEnumIterator;

    use super::*;
    use crate::base::Transformation;

    #[test]
    fn test_conventional_transformation_matrix() {
        for centering in LayerCentering::iter() {
            assert_eq!(
                Transformation::from_linear(centering.linear()).size,
                centering.order()
            );
        }
    }

    #[test]
    fn test_lattice_points_in_plane() {
        for centering in LayerCentering::iter() {
            for p in centering.lattice_points() {
                assert_eq!(p[2], 0.0);
            }
            assert_eq!(centering.lattice_points().len(), centering.order());
        }
    }
}