feff10 0.2.2

Rust wrapper for FEFF10 X-ray absorption spectroscopy calculations
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

pub mod config;
pub mod error;
pub mod input;
pub mod output;
pub mod pipeline;
pub mod stage;
pub mod worker;

// Re-exports for convenience
pub use config::{FeffConfig, FeffConfigBuilder};
pub use error::Error;
pub use input::{
    Atom, CardToken, FeffInput, InputCard, Potential, ResolvedFeffInput, ResolvedFortranInput,
    TypedCard,
};
pub use output::{FeffOutputs, FeffTable, OutputFile, OutputKind, PathEntry, PathLeg, PathsDat};
pub use pipeline::{FeffPipeline, PipelineResult, StageResult};
pub use stage::Stage;

use std::path::{Path, PathBuf};

/// Run a FEFF calculation from a feff.inp file.
///
/// Parses the input file, validates it, builds a default configuration
/// (all stages from CONTROL card), and runs the full pipeline.
///
/// # Example
///
/// ```no_run
/// let result = feff10::run("feff.inp", "./work")?;
/// for sr in &result.stages {
///     println!("{}: {:.3}s", sr.stage, sr.duration.as_secs_f64());
/// }
/// # Ok::<(), feff10::Error>(())
/// ```
pub fn run(
    input_path: impl AsRef<Path>,
    work_dir: impl Into<PathBuf>,
) -> Result<PipelineResult, Error> {
    let input = FeffInput::from_file(input_path)?;
    run_input(input, work_dir)
}

/// Run a FEFF calculation from a pre-built [`FeffInput`].
///
/// Validates the input, builds a default configuration, and runs the
/// full pipeline. Use this when you've constructed or modified input
/// programmatically.
///
/// # Example
///
/// ```no_run
/// let mut inp = feff10::FeffInput::from_file("feff.inp")?;
/// inp.s02 = Some(0.9);
/// let result = feff10::run_input(inp, "./work")?;
/// # Ok::<(), feff10::Error>(())
/// ```
pub fn run_input(input: FeffInput, work_dir: impl Into<PathBuf>) -> Result<PipelineResult, Error> {
    input.validate()?;
    let config = FeffConfigBuilder::new()
        .work_dir(work_dir.into())
        .input(input)
        .build()?;
    FeffPipeline::new(config).run()
}

/// Run a FEFF calculation from raw feff.inp text.
///
/// Parses the string as feff.inp content, validates it, and runs the
/// full pipeline.
///
/// # Example
///
/// ```no_run
/// let content = std::fs::read_to_string("feff.inp")?;
/// let result = feff10::run_str(&content, "./work")?;
/// # Ok::<(), feff10::Error>(())
/// ```
pub fn run_str(content: &str, work_dir: impl Into<PathBuf>) -> Result<PipelineResult, Error> {
    let input = FeffInput::parse(content)?;
    run_input(input, work_dir)
}

/// Validate a feff.inp file without running any calculations.
///
/// Parses the file and checks semantic correctness (potentials, atoms,
/// absorber site, etc.). Returns `Ok(())` if the input is valid.
///
/// # Example
///
/// ```no_run
/// feff10::validate("feff.inp")?;
/// println!("Input is valid");
/// # Ok::<(), feff10::Error>(())
/// ```
pub fn validate(input_path: impl AsRef<Path>) -> Result<(), Error> {
    let input = FeffInput::from_file(input_path)?;
    input.validate()
}

/// Validate raw feff.inp text without running any calculations.
///
/// # Example
///
/// ```no_run
/// let content = std::fs::read_to_string("feff.inp")?;
/// feff10::validate_str(&content)?;
/// # Ok::<(), feff10::Error>(())
/// ```
pub fn validate_str(content: &str) -> Result<(), Error> {
    let input = FeffInput::parse(content)?;
    input.validate()
}