castep-cell-io 0.4.0

I/O library for CASTEP .cell and .param file formats
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use castep_cell_fmt::{CellValue, ToCellValue, FromCellValue, CResult, query::value_as_f64};

#[derive(Debug, Clone, Copy, PartialEq, bon::Builder)]
/// A line of block `KpointsList`
/// The first three entries on a line are the fractional positions of the
/// k-point relative to the reciprocal space lattice vectors.
///
/// The final entry on a line is the weight of the k-point relative to the
/// others specified. The sum of the weights must be equal to 1.
pub struct Kpoint {
    pub coord: [f64; 3],
    pub weight: f64,
}

impl PartialOrd for Kpoint {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        self.coord
            .iter()
            .zip(other.coord.iter())
            .find_map(|(a, b)| {
                let diff = a - b;
                if diff.abs() > 1e-6 {
                    a.partial_cmp(b)
                } else {
                    None
                }
            })
            .or(Some(std::cmp::Ordering::Equal))
    }
}

impl FromCellValue for Kpoint {
    fn from_cell_value(value: &CellValue<'_>) -> CResult<Self> {
        match value {
            CellValue::Array(arr) if arr.len() == 4 => {
                let coord = [
                    value_as_f64(&arr[0])?,
                    value_as_f64(&arr[1])?,
                    value_as_f64(&arr[2])?,
                ];
                let weight = value_as_f64(&arr[3])?;
                Ok(Kpoint { coord, weight })
            }
            _ => Err(castep_cell_fmt::Error::Message(
                "Kpoint must be an array of 4 floats".into(),
            )),
        }
    }
}

impl ToCellValue for Kpoint {
    fn to_cell_value(&self) -> CellValue<'_> {
        CellValue::Array(
            self.coord
                .into_iter()
                .map(CellValue::Float)
                .chain([CellValue::Float(self.weight)])
                .collect(),
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_kpoint_from_cell_value() {
        let val = CellValue::Array(vec![
            CellValue::Float(0.5),
            CellValue::Float(0.25),
            CellValue::Float(0.0),
            CellValue::Float(1.0),
        ]);
        let kpt = Kpoint::from_cell_value(&val).unwrap();
        assert_eq!(kpt.coord, [0.5, 0.25, 0.0]);
        assert_eq!(kpt.weight, 1.0);
    }

    #[test]
    fn test_kpoint_insufficient_elements() {
        let val = CellValue::Array(vec![
            CellValue::Float(0.5),
            CellValue::Float(0.25),
            CellValue::Float(0.0),
        ]);
        assert!(Kpoint::from_cell_value(&val).is_err());
    }

    #[test]
    fn test_kpoint_to_cell_value() {
        let kpt = Kpoint {
            coord: [0.5, 0.25, 0.0],
            weight: 1.0,
        };
        let val = kpt.to_cell_value();
        match val {
            CellValue::Array(arr) => {
                assert_eq!(arr.len(), 4);
                assert_eq!(arr[3], CellValue::Float(1.0));
            }
            _ => panic!("Expected Array"),
        }
    }

    #[test]
    fn test_kpoint_partial_ord() {
        let kpt1 = Kpoint {
            coord: [0.0, 0.0, 0.0],
            weight: 1.0,
        };
        let kpt2 = Kpoint {
            coord: [0.5, 0.0, 0.0],
            weight: 1.0,
        };
        assert!(kpt1 < kpt2);
    }
}