pdbcat 0.1.1

Terminal-based PDB/mmCIF molecular structure viewer
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

//! Biological assembly representations

use nalgebra::{Matrix3, Vector3};

/// Rigid transform for assembly operations
#[derive(Debug, Clone)]
pub struct Transform {
    pub rotation: Matrix3<f32>,
    pub translation: Vector3<f32>,
}

impl Transform {
    pub fn identity() -> Self {
        Self {
            rotation: Matrix3::identity(),
            translation: Vector3::zeros(),
        }
    }

    pub fn apply(&self, point: Vector3<f32>) -> Vector3<f32> {
        self.rotation * point + self.translation
    }

    /// Compose transforms: apply `before`, then `after`.
    pub fn compose(after: &Transform, before: &Transform) -> Transform {
        Transform {
            rotation: after.rotation * before.rotation,
            translation: after.rotation * before.translation + after.translation,
        }
    }
}

impl Default for Transform {
    fn default() -> Self {
        Self::identity()
    }
}

/// One instance of an assembly (transform + optional chain filter)
#[derive(Debug, Clone)]
pub struct AssemblyInstance {
    pub transform: Transform,
    pub chains: Option<Vec<char>>,
}

impl AssemblyInstance {
    pub fn applies_to_chain(&self, chain_id: char) -> bool {
        match &self.chains {
            Some(chains) => chains.contains(&chain_id),
            None => true,
        }
    }
}

/// Biological assembly definition
#[derive(Debug, Clone)]
pub struct Assembly {
    pub id: String,
    pub instances: Vec<AssemblyInstance>,
}

impl Assembly {
    pub fn single_identity() -> Self {
        Self {
            id: "1".to_string(),
            instances: vec![AssemblyInstance {
                transform: Transform::identity(),
                chains: None,
            }],
        }
    }
}