xtalforge-cli 0.0.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

//! The `supercell` and `slab` commands.

use xtalforge::core::limits::check_supercell;
use xtalforge::core::{Limits as CoreLimits, Structure, make_slab};

use crate::format::StructureFormat;
use crate::{Cli, CliError, input, output};

/// Builds an `na x nb x nc` supercell and emits it.
///
/// # Errors
///
/// Returns [`CliError`] for a read error, a refused size, a failed supercell
/// or an output failure.
pub(crate) fn supercell(
    cli: &Cli,
    path: &str,
    repeats: [u32; 3],
    out: Option<&str>,
    format: Option<StructureFormat>,
) -> Result<(), CliError> {
    let structure = input::read_structure_path(path).map_err(CliError::core)?;
    check_size(cli, &structure, repeats)?;
    let built = structure
        .supercell_with_limits(
            repeats[0],
            repeats[1],
            repeats[2],
            &CoreLimits::new(cli.limits.profile()),
        )
        .map_err(CliError::core)?;
    output::emit_structure(cli, &built, out, format)
}

/// Cuts a slab and emits it.
///
/// # Errors
///
/// Returns [`CliError`] for a read error, a degenerate plane, a failed cut or
/// an output failure.
pub(crate) fn slab(
    cli: &Cli,
    path: &str,
    hkl: [i32; 3],
    layers: u32,
    vacuum: f64,
    out: Option<&str>,
    format: Option<StructureFormat>,
) -> Result<(), CliError> {
    let structure = input::read_structure_path(path).map_err(CliError::core)?;
    let slab = make_slab(&structure, hkl, layers, vacuum, 0.0).map_err(CliError::core)?;
    output::emit_structure(cli, &slab.structure, out, format)
}

fn check_size(cli: &Cli, structure: &Structure, repeats: [u32; 3]) -> Result<(), CliError> {
    let [na, nb, nc] = repeats;
    let matrix = [
        [f64::from(na), 0.0, 0.0],
        [0.0, f64::from(nb), 0.0],
        [0.0, 0.0, f64::from(nc)],
    ];
    let verdict = check_supercell(
        &CoreLimits::new(cli.limits.profile()),
        structure.sites().len() as u64,
        matrix,
    )
    .map_err(CliError::core)?;
    if verdict.refused() {
        return Err(CliError::new("limit_exceeded", verdict.to_string()));
    }
    if verdict.warned() && !cli.quiet {
        eprintln!("warning: {verdict}");
    }
    Ok(())
}