cealign 0.1.0

Implementation of the Combinatorial Extension (cealign) algorithm to align protein structures
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
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use cealign::ce;
use cealign::structure::{Geometry, Validations};
use cealign::utils;
use clap::Parser;
use log::{debug, error, info};
use std::process::exit;
use std::time::Instant;

#[derive(Parser)]
#[command(author, version, about, long_about = None)]
struct Args {
    #[arg(short = 'm', help = "Path to the mobile structure")]
    mobile: String,

    #[arg(short = 't', help = "Path to the target structure")]
    target: String,

    #[arg(
        short = 'o',
        long = "output",
        help = "Save aligned structures as PDB files; they will be saved in the current directory as `<name>_aln.pdb`",
        default_value = "false"
    )]
    output: bool,

    #[arg(
        short = 'v',
        long = "verbose",
        help = "Increase output verbosity",
        default_value = "false"
    )]
    verbose: bool,

    #[arg(
        short = 'r',
        long = "randomize",
        help = "Randomly rotate both the mobile and the target for development/debug purposes",
        default_value = "false"
    )]
    randomize: bool,

    #[cfg(feature = "plot")]
    #[arg(
        short = 'p',
        long = "plot",
        help = "Save the alignment path plot as plot.png",
        default_value = "false"
    )]
    plot: bool,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args = Args::parse();

    if args.verbose {
        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();
        debug!("Verbose mode enabled");
    } else {
        env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("warn")).init();
    }

    let mut pdb_i = match pdbtbx::open(&args.mobile) {
        Ok((pdb, _warnings)) => pdb,
        Err(e) => {
            error!("Error opening PDB file {:?}: {:?}", args.mobile, e);
            exit(1)
        }
    };

    let mut pdb_j = match pdbtbx::open(&args.target) {
        Ok((pdb, _warnings)) => pdb,
        Err(e) => {
            error!("Error opening PDB file {:?}: {:?}", args.target, e);
            exit(1)
        }
    };

    if pdb_i.is_multimodel() || pdb_j.is_multimodel() {
        error!("Multimodel PDB files are not supported");
        exit(1);
    }

    if args.randomize {
        info!("Randomly rotating structures for development purposes");
        pdb_i.randomly_rotate();
        pdb_j.randomly_rotate();
    }

    #[cfg(feature = "plot")]
    let plot = args.plot;
    #[cfg(not(feature = "plot"))]
    let plot = false;

    let start = Instant::now();
    let (pdb_i_aln, pdb_j_aln, aligned_rmsd, _) = ce::align(pdb_i, pdb_j, plot);
    let _ = start.elapsed();

    println!("{:.3}", aligned_rmsd);

    #[cfg(feature = "plot")]
    if plot {
        println!("Saved: plot.png");
    }

    if args.output {
        let mobile_output = utils::aln_filename(&args.mobile);
        let target_output = utils::aln_filename(&args.target);

        let _ = pdbtbx::save_pdb(&pdb_i_aln, &mobile_output, pdbtbx::StrictnessLevel::Strict);
        let _ = pdbtbx::save_pdb(&pdb_j_aln, &target_output, pdbtbx::StrictnessLevel::Strict);

        println!("Saved: {} and {}", mobile_output, target_output);
    }

    Ok(())
}