xtalforge-cli 1.2.0

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
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
130
131
132
133
134
135
136
137
138
139

//! Phase 9 edit commands: rattle, site edits, interpolation and optimal cells.

use xtalforge::core::{RattleOptions, StructureSummary};

use crate::feature_args::FeatureAction;
use crate::feature_commands::{core_error, edit, emit_structure, load, write_frames};
use crate::{Cli, CliError};

pub(crate) fn run(cli: &Cli, action: &FeatureAction) -> Result<(), CliError> {
    match action {
        FeatureAction::Rattle {
            path,
            amplitude,
            seed,
            bounded,
            out,
            format,
        } => {
            let structure = load(path)?;
            let report = xtalforge::core::rattle(
                &structure,
                &RattleOptions {
                    amplitude: *amplitude,
                    seed: *seed,
                    bounded: *bounded,
                    ..RattleOptions::default()
                },
            )
            .map_err(core_error)?;
            if cli.json {
                println!(
                    "{}",
                    serde_json::json!({
                        "n_atoms": report.n_atoms,
                        "max_displacement": report.max_displacement,
                        "rms_displacement": report.rms_displacement,
                    })
                );
            } else if !cli.quiet {
                println!(
                    "rattled {} atoms: max={:.4} A rms={:.4} A",
                    report.n_atoms, report.max_displacement, report.rms_displacement
                );
            }
            emit_structure(cli, &report.structure, out.as_deref(), *format)
        }
        FeatureAction::Edit {
            path,
            add,
            remove,
            replace,
            move_site,
            species,
            fraction,
            seed,
            sort,
            wrap,
            out,
            format,
        } => edit(
            cli,
            path,
            add,
            remove,
            replace,
            move_site,
            species,
            *fraction,
            *seed,
            sort.as_deref(),
            *wrap,
            out.as_deref(),
            *format,
        ),
        FeatureAction::Interpolate {
            first,
            second,
            images,
            out,
            format: _,
        } => {
            let start = load(first)?;
            let end = load(second)?;
            let options = xtalforge::symmetry::MatcherOptions {
                allow_supercell: true,
                ..xtalforge::symmetry::MatcherOptions::default()
            };
            let frames = xtalforge::symmetry::interpolate_matched(&start, &end, *images, &options)
                .map_err(core_error)?;
            if cli.json {
                let summaries: Vec<StructureSummary> = frames
                    .iter()
                    .map(|frame| frame.summary())
                    .collect::<Result<_, _>>()
                    .map_err(core_error)?;
                println!(
                    "{}",
                    serde_json::json!({
                        "n_frames": frames.len(),
                        "frames": summaries,
                    })
                );
            } else if !cli.quiet {
                println!("interpolated {} frames", frames.len());
            }
            write_frames(cli, &frames, out.as_deref())
        }
        FeatureAction::OptimalSupercell {
            path,
            cells,
            out,
            format,
        } => {
            let structure = load(path)?;
            let choice =
                xtalforge::core::optimal_supercell(&structure, *cells).map_err(core_error)?;
            if cli.json {
                println!(
                    "{}",
                    serde_json::json!({
                        "matrix": choice.matrix,
                        "cells": choice.cells,
                        "score": choice.score,
                        "n_atoms": choice.structure.sites().len(),
                    })
                );
            } else if !cli.quiet {
                println!(
                    "supercell det={} score={:.6} sites={}",
                    choice.cells,
                    choice.score,
                    choice.structure.sites().len()
                );
            }
            emit_structure(cli, &choice.structure, out.as_deref(), *format)
        }
        _ => Err(CliError::input("unsupported edit action")),
    }
}