molframe-cif 0.1.1

PDBx/mmCIF reading and writing for molframe
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

//! Classifying coordinate models as dense or ragged.
//!
//! Dense storage is used only when every non-coordinate atom-site value agrees
//! row for row. Any difference in identity or annotation requires independent
//! structures so no model's data is silently replaced by the first model's.

use crate::document::Category;

/// One contiguous model in deposition order.
#[derive(Clone, Copy)]
struct ModelRange {
    number: i64,
    start: usize,
    end: usize,
}

/// Deposited model numbers when the category is genuinely ragged.
pub(super) fn ragged_model_numbers(category: &Category, only_first: bool) -> Vec<i64> {
    if only_first {
        return Vec::new();
    }
    let ranges = ranges(category);
    let Some(first) = ranges.first() else {
        return Vec::new();
    };
    if ranges
        .iter()
        .skip(1)
        .all(|candidate| same_atoms(category, *first, *candidate))
    {
        return Vec::new();
    }
    ranges.iter().map(|range| range.number).collect()
}

fn ranges(category: &Category) -> Vec<ModelRange> {
    let mut ranges: Vec<ModelRange> = Vec::new();
    for row in 0..category.row_count() {
        let candidate = category
            .value("pdbx_PDB_model_num", row)
            .and_then(crate::document::CifValue::as_integer);
        let Some(number) = candidate else {
            push_range(&mut ranges, 1, row);
            continue;
        };
        push_range(&mut ranges, number, row);
    }
    ranges
}

fn push_range(ranges: &mut Vec<ModelRange>, number: i64, row: usize) {
    if let Some(current) = ranges.last_mut()
        && current.number == number
    {
        current.end = row + 1;
    } else {
        ranges.push(ModelRange {
            number,
            start: row,
            end: row + 1,
        });
    }
}

fn same_atoms(category: &Category, left: ModelRange, right: ModelRange) -> bool {
    if left.end - left.start != right.end - right.start {
        return false;
    }
    let rows = (left.start..left.end).zip(right.start..right.end);
    for (left_row, right_row) in rows {
        for item in category.items() {
            if is_frame_coordinate(item) {
                continue;
            }
            if category.value(item, left_row) != category.value(item, right_row) {
                return false;
            }
        }
    }
    true
}

fn is_frame_coordinate(item: &str) -> bool {
    matches!(
        item,
        "Cartn_x" | "Cartn_y" | "Cartn_z" | "pdbx_PDB_model_num"
    )
}

#[cfg(test)]
#[path = "ensemble_tests.rs"]
mod tests;