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

use std::collections::HashMap; 

use scoring::score;
use conformation::Pose;

// Sampling (smaller to larger, Move > Protocol)

// Available_protocols
//
//
//
//
//


//let mut protocols = HashMap::new(); 

//protocols.insert(String::from("score"), Protocol { components: vec![Box::new(ScoreOnlyMove {})] }) 

pub fn get_protocol(protocol_name: &str) -> Protocol {
    // this can get a protocol from a dict of protocols defined in
    // protocols.rs. But, for now, we hard-code a protocol in
    let protocol = Protocol {
        components: vec![
            // go ahread, try it, it's fun!
            Box::new(ScoreOnlyMove {}),
            // Box::new(GridMove {}),
            Box::new(ScoreOnlyMove {}),
        ]
    };

    protocol
}

// protocol object
pub struct Protocol {
    pub components: Vec<Box<Move>>,
}

impl Protocol {
    pub fn run(&self, pose: &mut Pose) {
        for component in self.components.iter() {
            component.apply(pose);
        }
    }
}

// mover trait
pub trait Move {
    fn apply(&self, pose: &mut Pose);
}

// list of movers
pub struct ScoreOnlyMove {}
pub struct GridMove {}

// implementations for movers
impl Move for ScoreOnlyMove {
    fn apply(&self, pose: &mut Pose) {
        // code to run when applying

        let result: f64 = score(pose);
        println!("ScoreOnlyMove: result is {}", result);
    }
}

// impl Move for GridMove {
//     fn apply(&self, pose: &mut Pose) {
//         // get extents of the active site
//         // or can read in from a argument the 6 XYZ objects at the corners

//         // construct the grid
//         // this will be like the Submaranian paper
//         // we will evaluate hydro and electrostatic terms on each grid point
//         // this makes it sequence-independent (and structure-independent)
//         // just like our PLOS paper

//         println!("GridMove: activating grid"); 

//         let grid = vec!(f64);  

//         for atom in pose.atoms {
//             //println!(atom.xyz()); 
//         }



//     }
// }