rgsaddle 0.1.0

Band and minimum-mode saddle mechanics over rgmin steppers.
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
119
120
121
122
123
124
125
126
127
128
129

//! Maturin / PyO3 entry for `rgsaddle`. Typed enums live here so
//! Python does not re-declare C ordinals.

use pyo3::prelude::*;
use pyo3::types::PyDict;

use crate::{
    CellChart, EigenDevice, ExpandKind, ForceGate, HessUpdate, IrcKind, MinModeKind, RestrictedKind,
};

fn mint_int_enum<'py>(
    py: Python<'py>,
    name: &str,
    members: &[(&str, i32)],
) -> PyResult<Bound<'py, PyAny>> {
    let dict = PyDict::new(py);
    for (key, val) in members {
        dict.set_item(*key, *val)?;
    }
    py.import("enum")?.getattr("IntEnum")?.call1((name, dict))
}

/// pyo3 module. Exposed to Python as `rgsaddle`.
#[pymodule]
fn rgsaddle(m: &Bound<'_, PyModule>) -> PyResult<()> {
    let py = m.py();
    m.add("__version__", env!("CARGO_PKG_VERSION"))?;
    m.add(
        "ForceGate",
        mint_int_enum(
            py,
            "ForceGate",
            &[
                ("L2_NORM", ForceGate::L2Norm.to_abi()),
                ("LINF_NORM", ForceGate::LinfNorm.to_abi()),
                ("MAX_FORCE_ON_ATOM", ForceGate::MaxForceOnAtom.to_abi()),
            ],
        )?,
    )?;
    m.add(
        "HessUpdate",
        mint_int_enum(
            py,
            "HessUpdate",
            &[
                ("BFGS", HessUpdate::Bfgs.to_abi()),
                ("TS_BFGS", HessUpdate::TsBfgs.to_abi()),
            ],
        )?,
    )?;
    m.add(
        "IrcKind",
        mint_int_enum(
            py,
            "IrcKind",
            &[
                ("GS2", IrcKind::Gs2.to_abi()),
                ("MOROKUMA", IrcKind::Morokuma.to_abi()),
            ],
        )?,
    )?;
    m.add(
        "MinModeKind",
        mint_int_enum(
            py,
            "MinModeKind",
            &[
                ("DIMER", MinModeKind::Dimer.to_abi()),
                ("LANCZOS", MinModeKind::Lanczos.to_abi()),
            ],
        )?,
    )?;
    m.add(
        "EigenDevice",
        mint_int_enum(
            py,
            "EigenDevice",
            &[
                ("HOST", EigenDevice::Host.to_abi()),
                ("DLPK", EigenDevice::Dlpk.to_abi()),
            ],
        )?,
    )?;
    m.add(
        "ExpandKind",
        mint_int_enum(
            py,
            "ExpandKind",
            &[
                ("LANCZOS", ExpandKind::Lanczos.to_abi()),
                ("GD", ExpandKind::Gd.to_abi()),
                ("JD0", ExpandKind::Jd0.to_abi()),
                ("JD0_ALT", ExpandKind::Jd0Alt.to_abi()),
                ("MJD0", ExpandKind::Mjd0.to_abi()),
                ("MJD0_ALT", ExpandKind::Mjd0Alt.to_abi()),
            ],
        )?,
    )?;
    m.add(
        "CellChart",
        mint_int_enum(
            py,
            "CellChart",
            &[
                ("ENTRIES", CellChart::Entries.to_abi()),
                ("LOG_DEFORM", CellChart::LogDeform.to_abi()),
            ],
        )?,
    )?;
    m.add(
        "RestrictedKind",
        mint_int_enum(
            py,
            "RestrictedKind",
            &[
                ("TRUST_REGION", RestrictedKind::TrustRegion.to_abi()),
                (
                    "MAX_INTERNAL_STEP",
                    RestrictedKind::MaxInternalStep.to_abi(),
                ),
                (
                    "RESTRICTED_ATOMIC_STEP",
                    RestrictedKind::RestrictedAtomicStep.to_abi(),
                ),
            ],
        )?,
    )?;
    Ok(())
}