Struct FileRunRequest 

pub struct FileRunRequest {
    pub input: PathBuf,
    pub output: PathBuf,
    pub existing_output_policy: ExistingOutputPolicy,
}

File-backed pipeline request.

Fields

input: PathBuf

Root feff.inp file.

output: PathBuf

Directory that receives FEFF-compatible outputs.

existing_output_policy: ExistingOutputPolicy

Existing-output policy.

Implementations

impl FileRunRequest

pub fn new(input: impl Into<PathBuf>, output: impl Into<PathBuf>) -> Self

Create a request using validated cache reuse.

Examples found in repository

examples/spectrum.rs (line 8)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut args = std::env::args().skip(1);
    let input = args.next().ok_or("provide input and output paths")?;
    let output = args.next().ok_or("provide an output directory")?;
    let report = Runner::new().run_files(FileRunRequest::new(input, &output))?;
    let spectrum = io::xmu_dat::read_xmu_dat(std::path::Path::new(&output).join("xmu.dat"))?;
    println!(
        "{} completed stages; {} spectrum points",
        report.stages.len(),
        spectrum.photon_energy_ev.len()
    );
    if let Some(point) = spectrum.point(0) {
        println!(
            "First point: {} eV, μ={}",
            point.photon_energy.value(),
            point.mu
        );
    }
    Ok(())
}

examples/benchmark.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 4 {
        return Err("expected INPUT OUTPUT MODE THREADS".into());
    }
    let input = PathBuf::from(&args[0]);
    let output = PathBuf::from(&args[1]);
    let threads: usize = args[3].parse()?;
    let mut runner = Runner::new();
    if let Some(n) = NonZeroUsize::new(threads) {
        runner = runner.with_threads(n);
    }
    let start = Instant::now();
    let (stages, bytes) = if args[2] == "memory" || args[2] == "typed" {
        if args[2] == "typed" {
            runner = runner.with_artifacts(ArtifactSelection::None);
        }
        let result = runner.run_in_memory(MemoryRunRequest::new(std::fs::read(input)?))?;
        (
            result.report.stages.len(),
            result
                .artifacts
                .iter()
                .map(|file| file.bytes.len() as u64)
                .sum::<u64>(),
        )
    } else {
        let policy = if args[2] == "recompute" {
            ExistingOutputPolicy::Recompute
        } else {
            ExistingOutputPolicy::ReuseValidated
        };
        let report = runner
            .run_files(FileRunRequest::new(input, &output).with_existing_output_policy(policy))?;
        let bytes = report
            .artifacts
            .iter()
            .map(|path| std::fs::metadata(output.join(path)).map(|m| m.len()))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .sum::<u64>();
        (report.stages.len(), bytes)
    };
    println!(
        "{{\"seconds\":{},\"stages\":{},\"artifact_bytes\":{}}}",
        start.elapsed().as_secs_f64(),
        stages,
        bytes
    );
    Ok(())
}

pub const fn with_existing_output_policy( self, policy: ExistingOutputPolicy, ) -> Self

Select how existing output is handled.

Examples found in repository

examples/benchmark.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<_> = std::env::args().skip(1).collect();
    if args.len() != 4 {
        return Err("expected INPUT OUTPUT MODE THREADS".into());
    }
    let input = PathBuf::from(&args[0]);
    let output = PathBuf::from(&args[1]);
    let threads: usize = args[3].parse()?;
    let mut runner = Runner::new();
    if let Some(n) = NonZeroUsize::new(threads) {
        runner = runner.with_threads(n);
    }
    let start = Instant::now();
    let (stages, bytes) = if args[2] == "memory" || args[2] == "typed" {
        if args[2] == "typed" {
            runner = runner.with_artifacts(ArtifactSelection::None);
        }
        let result = runner.run_in_memory(MemoryRunRequest::new(std::fs::read(input)?))?;
        (
            result.report.stages.len(),
            result
                .artifacts
                .iter()
                .map(|file| file.bytes.len() as u64)
                .sum::<u64>(),
        )
    } else {
        let policy = if args[2] == "recompute" {
            ExistingOutputPolicy::Recompute
        } else {
            ExistingOutputPolicy::ReuseValidated
        };
        let report = runner
            .run_files(FileRunRequest::new(input, &output).with_existing_output_policy(policy))?;
        let bytes = report
            .artifacts
            .iter()
            .map(|path| std::fs::metadata(output.join(path)).map(|m| m.len()))
            .collect::<Result<Vec<_>, _>>()?
            .into_iter()
            .sum::<u64>();
        (report.stages.len(), bytes)
    };
    println!(
        "{{\"seconds\":{},\"stages\":{},\"artifact_bytes\":{}}}",
        start.elapsed().as_secs_f64(),
        stages,
        bytes
    );
    Ok(())
}

Trait Implementations

impl Clone for FileRunRequest

fn clone(&self) -> FileRunRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FileRunRequest

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for FileRunRequest

impl PartialEq for FileRunRequest

fn eq(&self, other: &FileRunRequest) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for FileRunRequest