molgfx-core 0.1.2

The semantic scene graph: columnar tables, GPU record layouts, the borrowed coordinate seam.
Documentation 
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

use super::*;

#[test]
fn strings_and_builders_lower_to_the_same_selection_ir() {
    let parsed = match "polymer and not water".parse::<Select>() {
        Ok(parsed) => parsed,
        Err(error) => panic!("selection parses: {error}"),
    };
    assert_eq!(parsed, Select::polymer().and(Select::water().negate()));
}

#[test]
fn boolean_precedence_and_parentheses_are_deterministic() {
    let implicit = match "protein or nucleic and not water".parse::<Select>() {
        Ok(parsed) => parsed,
        Err(error) => panic!("selection parses: {error}"),
    };
    assert_eq!(
        implicit,
        Select::protein().or(Select::nucleic().and(Select::water().negate()))
    );
    let grouped = match "(protein or nucleic) and not water".parse::<Select>() {
        Ok(parsed) => parsed,
        Err(error) => panic!("selection parses: {error}"),
    };
    assert_ne!(implicit, grouped);
}

#[test]
fn spatial_strings_use_the_validated_builder() {
    let parsed = match "within 5.5 of (ligand or water)".parse::<Select>() {
        Ok(parsed) => parsed,
        Err(error) => panic!("selection parses: {error}"),
    };
    let expected = match Select::within(5.5, Select::ligands().or(Select::water())) {
        Ok(expected) => expected,
        Err(error) => panic!("typed selection builds: {error}"),
    };
    assert_eq!(parsed, expected);
}

#[test]
fn hierarchy_and_property_strings_use_the_same_typed_builders() {
    let parsed = match "chain A and resname GLY and element C and b_factor >= 10".parse::<Select>()
    {
        Ok(parsed) => parsed,
        Err(error) => panic!("rich selection parses: {error}"),
    };
    let b_factor = match Select::b_factor(PropertyComparison::GreaterOrEqual, 10.0) {
        Ok(value) => value,
        Err(error) => panic!("B-factor predicate builds: {error}"),
    };
    let expected = match Select::chain("A") {
        Ok(value) => value,
        Err(error) => panic!("chain predicate builds: {error}"),
    }
    .and(match Select::residue_name("GLY") {
        Ok(value) => value,
        Err(error) => panic!("residue predicate builds: {error}"),
    })
    .and(match Select::element("C") {
        Ok(value) => value,
        Err(error) => panic!("element predicate builds: {error}"),
    })
    .and(b_factor);
    assert_eq!(parsed, expected);
}

#[test]
fn geometric_and_secondary_selection_builders_validate_input() {
    assert!(Select::in_sphere(molgfx_math::Vec3::ZERO, 2.0).is_ok());
    assert!(Select::in_box(-molgfx_math::Vec3::ONE, molgfx_math::Vec3::ONE).is_ok());
    assert!(Select::in_sphere(molgfx_math::Vec3::ZERO, f32::NAN).is_err());
    assert!(Select::in_box(molgfx_math::Vec3::ONE, -molgfx_math::Vec3::ONE).is_err());
    assert_eq!(
        Select::helix(),
        Select::secondary(SecondaryStructure::Helix)
    );
    assert_eq!(
        Select::hydrogen(),
        Select::from_str("hydrogen").ok().unwrap()
    );
}

#[test]
fn malformed_strings_return_the_stable_selection_error() {
    for source in [
        "",
        "within nope of ligand",
        "protein and",
        "(water",
        "magic",
    ] {
        let Err(error) = source.parse::<Select>() else {
            panic!("malformed selection must fail: {source}")
        };
        assert_eq!(error.code(), "MOLGFX-E0034");
    }
    assert!(Select::within(f32::NAN, Select::all()).is_err());
    assert!(Select::within(-1.0, Select::all()).is_err());
}