molar_bin 1.3.4

Molar main binary 
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

use std::collections::HashSet;

use anyhow::{bail, Context, Result};
use log::info;
use molar::prelude::*;

pub(super) fn command_rearrange(
    infile: &str,
    outfile: &str,
    begin: &Vec<String>,
    end: &Vec<String>,
) -> Result<()> {
    // Sanity check
    if begin.is_empty() && end.is_empty() {
        bail!("Provide at least one selection for rearranging!");
    }

    if !begin.is_empty() {
        info!("Selections to put in the beginning:");
        for s in begin.iter() {
            info!("\t{s}");
        }
    }

    if !end.is_empty() {
        info!("Selections to put at the end:");
        for s in end.iter() {
            info!("\t{s}");
        }
    }

    // Make selections
    info!("Rearranging file '{infile}'...");
    let in_sys = System::from_file(infile)?;
    let begin_sels = begin
        .iter()
        .map(|s| in_sys.select_bound(s))
        .collect::<Result<Vec<_>,_>>()
        .with_context(|| "can't create begin selections for rearranging")?;

    let end_sels = end
        .iter()
        .map(|s| in_sys.select_bound(s))
        .collect::<Result<Vec<_>,_>>()
        .with_context(|| "can't create end selections for rearranging")?;

    // Check overlap of selections
    let mut used = HashSet::<usize>::default();
    for sel in begin_sels.iter().chain(end_sels.iter()) {
        for i in sel.iter_index() {
            if !used.insert(i) {
                bail!("selections for rearrangement overlap at atom {i}");
            }
        }
    }

    // Get the rest of indexes, which are not used
    let all_ind = (0..in_sys.len()).collect::<HashSet<usize>>();

    let rest_sel = in_sys
        .select_bound(all_ind.difference(&used).cloned().collect::<Vec<_>>())
        .ok();

    // Create output builder
    let mut out = System::default();

    // Add beginning selections
    for sel in begin_sels {
        out.append(&sel)?;
    }

    // Add the rest if any
    if let Some(rest) = rest_sel {
        info!("There are {} untouched atoms", rest.len());
        out.append(&rest)?;
    }

    // Add ending selections
    for sel in end_sels {
        out.append(&sel)?;
    }

    info!("Writing rearranged to '{outfile}'...");
    // Write rearranged
    out.save(outfile)?;

    Ok(())
}