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

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

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
}

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);
        }
    }
}

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

// Manifest: available 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"); 

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



    }
}