hartree-cli 0.1.1

Command-line driver for hartree: an XYZ file plus a basis and method, to an SCF energy.
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
119

use std::process::Command;
use std::sync::atomic::{AtomicU32, Ordering};

static XYZ_SEQ: AtomicU32 = AtomicU32::new(0);

fn write_xyz(name: &str, body: &str) -> std::path::PathBuf {
    let seq = XYZ_SEQ.fetch_add(1, Ordering::Relaxed);
    let stem = name.strip_suffix(".xyz").unwrap_or(name);
    let path = std::env::temp_dir().join(format!("{stem}_{}_{seq}.xyz", std::process::id()));
    std::fs::write(&path, body).unwrap();
    path
}

fn water() -> std::path::PathBuf {
    write_xyz(
        "hartree_d3_water.xyz",
        "3\nwater\nO 0.0 0.0 0.117\nH 0.0 0.757 -0.470\nH 0.0 -0.757 -0.470\n",
    )
}

fn hartree(args: &[&str]) -> std::process::Output {
    Command::new(env!("CARGO_BIN_EXE_hartree"))
        .args(args)
        .output()
        .expect("run hartree")
}

fn grab(stdout: &str, label: &str) -> f64 {
    stdout
        .lines()
        .find(|l| l.starts_with(label))
        .unwrap_or_else(|| panic!("no '{label}' line in:\n{stdout}"))
        .split_whitespace()
        .rev()
        .nth(1)
        .unwrap()
        .parse()
        .unwrap()
}

#[test]
fn pbe_d3_reports_dispersion_and_consistent_total() {
    let xyz = water();
    let out = hartree(&[
        xyz.to_str().unwrap(),
        "--basis",
        "sto-3g",
        "--method",
        "pbe-d3",
        "--grid",
        "1",
    ]);
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        out.status.success(),
        "exit failure:\n{stdout}\n{}",
        String::from_utf8_lossy(&out.stderr)
    );
    assert!(
        stdout.contains("Kohn-Sham DFT: pbe"),
        "no KS line:\n{stdout}"
    );
    let scf = grab(&stdout, "total energy  ");
    let disp = grab(&stdout, "dispersion D3(BJ)");
    let total = grab(&stdout, "total energy + disp");
    assert!(disp < 0.0, "dispersion should be attractive: {disp}");
    assert!(
        (scf + disp - total).abs() < 1e-12,
        "total mismatch: {scf} + {disp} != {total}"
    );
}

#[test]
fn hf_d3_runs_and_reports() {
    let xyz = water();
    let out = hartree(&[
        xyz.to_str().unwrap(),
        "--basis",
        "sto-3g",
        "--method",
        "hf-d3",
    ]);
    let stdout = String::from_utf8_lossy(&out.stdout);
    assert!(
        out.status.success(),
        "exit failure:\n{stdout}\n{}",
        String::from_utf8_lossy(&out.stderr)
    );
    assert!(
        stdout.contains("dispersion D3(BJ)"),
        "no dispersion line:\n{stdout}"
    );
}

#[test]
fn svwn_d3_errors_cleanly() {
    let xyz = water();
    let out = hartree(&[xyz.to_str().unwrap(), "--method", "svwn-d3"]);
    assert!(!out.status.success(), "svwn-d3 should fail");
    let stderr = String::from_utf8_lossy(&out.stderr);
    assert!(
        stderr.contains("no D3(BJ) parametrization"),
        "unexpected error:\n{stderr}"
    );
}

#[test]
fn post_hf_d3_errors_cleanly() {
    let xyz = water();
    for method in ["mp2-d3", "ccsd-d3", "ccsd(t)-d3"] {
        let out = hartree(&[xyz.to_str().unwrap(), "--method", method]);
        assert!(!out.status.success(), "{method} should fail");
        let stderr = String::from_utf8_lossy(&out.stderr);
        assert!(
            stderr.contains("not supported for post-HF"),
            "{method} unexpected error:\n{stderr}"
        );
    }
}