xtalforge-cli 1.0.0-rc.1

Command-line interface for xtalforge.
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

//! Foundation commands that predate the Phase 1 domain surface.

use crate::{Cli, CliError, input};

/// Prints a structure summary from JSON, CIF, POSCAR or XYZ.
///
/// # Errors
///
/// Returns [`CliError`] for an unreadable input, an unknown format or a
/// structure without a summary.
pub(crate) fn info(cli: &Cli, path: &str) -> Result<(), CliError> {
    let text = input::read_source(path).map_err(CliError::core)?;
    let is_json =
        path.to_ascii_lowercase().ends_with(".json") || text.trim_start().starts_with('{');
    let summary = if is_json {
        xtalforge::core::structure_info(&text)
    } else {
        input::structure_from_text(&text, path).and_then(|structure| structure.summary())
    }
    .map_err(CliError::core)?;
    if cli.json {
        let payload = serde_json::to_string(&summary)
            .map_err(|error| CliError::new("json_error", error.to_string()))?;
        println!("{payload}");
    } else {
        println!(
            "{}: {} [{}] sites={} volume={:.3} A^3 density={:.4} g/cm^3 charge={:.3} p1={}",
            summary.name,
            summary.formula,
            summary.hall,
            summary.n_sites,
            summary.volume,
            summary.density,
            summary.total_charge,
            summary.is_p1
        );
    }
    Ok(())
}

/// Builds a lattice from six cell parameters and reports it.
///
/// # Errors
///
/// Returns [`CliError`] when the argument count is not six or the parameters
/// do not describe a valid cell.
pub(crate) fn cell(cli: &Cli, params: &[f64]) -> Result<(), CliError> {
    let [a, b, c, alpha, beta, gamma] = match params {
        [a, b, c, alpha, beta, gamma] => [*a, *b, *c, *alpha, *beta, *gamma],
        _ => {
            return Err(CliError::input(
                "cell needs six parameters: a b c alpha beta gamma",
            ));
        }
    };
    let lattice =
        xtalforge::core::lattice_info(a, b, c, alpha, beta, gamma).map_err(CliError::core)?;
    if cli.json {
        println!(
            "{}",
            serde_json::json!({
                "parameters": lattice.parameters(),
                "volume": lattice.volume(),
                "matrix": lattice.matrix(),
                "right_handed": lattice.is_right_handed(),
            })
        );
    } else {
        let [a, b, c, alpha, beta, gamma] = lattice.parameters();
        println!(
            "a={a:.6} b={b:.6} c={c:.6} alpha={alpha:.6} beta={beta:.6} gamma={gamma:.6} volume={:.6}",
            lattice.volume()
        );
        for row in lattice.matrix() {
            let [x, y, z] = row;
            println!("{x:12.6} {y:12.6} {z:12.6}");
        }
    }
    Ok(())
}

/// Computes the volume of a cell from six parameters.
///
/// # Errors
///
/// Returns [`CliError`] when the parameters do not describe a valid cell.
pub(crate) fn cell_volume(
    cli: &Cli,
    a: f64,
    b: f64,
    c: f64,
    alpha: f64,
    beta: f64,
    gamma: f64,
) -> Result<(), CliError> {
    let volume =
        xtalforge::core::cell_volume(a, b, c, alpha, beta, gamma).map_err(CliError::core)?;
    if cli.json {
        println!("{}", serde_json::json!({ "volume": volume }));
    } else {
        println!("{volume}");
    }
    Ok(())
}