transforms.py

#!/usr/bin/env python

__doc__ = "Write assembly transformation file in other formats."

import IMP
import IMP.multifit
from IMP import OptionParser


class Formatter(object):

    def __init__(self, fh):
        self.fh = fh

    def write_header(self, settings):
        pass


class ChimeraFormatter(Formatter):
    __doc__ = \
"""Each line in 'chimera' format lists the transformation index, the
cross correlation score, and then the transformation for each component,
as a rotation matrix (row-major order) and a translation in angstroms."""

    def write_line(self, ind, score, transforms):
        self.fh.write(str(ind) + "\t" + score + "\t")
        for t in transforms:
            for k in range(3):
                v = t.get_rotation().get_rotation_matrix_row(k)
                self.fh.write(
                    str(v[0]) + " " + str(v[1]) + " " + str(v[2]) + " ")
            v = t.get_translation()
            self.fh.write(
                str(v[0]) + " " + str(v[1]) + " " + str(v[2]) + " | ")
        self.fh.write("\n")


class DockRefFormatter(Formatter):
    __doc__ = \
"""Each line in 'dockref' format lists the transformation for each component,
as a set of three Euler angles (in radians about the fixed x, y and z axes)
and a translation in angstroms."""

    def write_header(self, sd):
        # write the name of the proteins
        for i in range(sd.get_number_of_component_headers()):
            self.fh.write(sd.get_component_header(i).get_name() + "|")
        self.fh.write("\n")

    def write_line(self, ind, score, transforms):
        for t in transforms:
            r = t.get_rotation()
            tr = t.get_translation()
            eulers = IMP.algebra.get_fixed_xyz_from_rotation(r)
            self.fh.write("%.6g %.6g %.6g %.6g %.6g %.6g|"
                          % (eulers.get_x(), eulers.get_y(), eulers.get_z(),
                             tr[0], tr[1], tr[2]))
        self.fh.write("\n")


formatters = {'chimera': ChimeraFormatter,
              'dockref': DockRefFormatter}


def parse_args():
    usage = """%prog [options] <asmb.input> <scores> <output file>

Write assembly transformation file in other formats.

""" + "\n\n".join([x.__doc__ for x in formatters.values()])

    parser = OptionParser(usage)
    parser.add_option("-f", "--format", default='chimera', type="choice",
                      choices=formatters.keys(),
                      help="type of output to generate ("
                           + ", ".join(formatters.keys())
                           + "; default: chimera)")
    options, args = parser.parse_args()
    if len(args) != 3:
        parser.error("incorrect number of arguments")
    return options, args


def run(asmb_fn, combs_fn, fmt):
    sd = IMP.multifit.read_settings(asmb_fn)
    sd.set_was_used(True)
    fmt.write_header(sd)
    # read the fitting files
    fits = []
    for i in range(sd.get_number_of_component_headers()):
        fn = sd.get_component_header(i).get_transformations_fn()
        fits.append(IMP.multifit.read_fitting_solutions(fn))
    for ind, line in enumerate(open(combs_fn)):
        s = line.split("|")
        score = s[2]
        comb = s[1]
        fmt.write_line(ind, score,
                       [fits[i][int(c)].get_fit_transformation()
                        for i, c in enumerate(comb.split())])


def main():
    options, args = parse_args()
    fmt = formatters[options.format](open(args[2], 'w'))
    run(args[0], args[1], fmt)

if __name__ == "__main__":
    main()