Beispiel #1
0
    def prepare_run(self, log, info):
        wd = info[Keys.WORKDIR]
        tandemexe = info.get('TANDEM_EXE')
        tandem2xmlexe = info.get('TANDEM2XML_EXE')

        # need to create a working copy to prevent replacement with app specific definitions
        app_info = info.copy()

        app_info = self._define_score(app_info, log)
        
        app_info["STATIC_MODS"],
        app_info["VARIABLE_MODS"],
        app_info['TERMINAL_MODS'] = genmodstr_to_engine(info["STATIC_MODS"],info["VARIABLE_MODS"],'XTandem')
        cleavage, enzyme   = enzymestr_to_engine(info['ENZYME'], 'XTandem')

        app_info['ENZYME'] =cleavage
        app_info['XTANDEM_SEMI_CLEAVAGE'] = enzyme
        #files required and written
        app_info['XTANDEM_PARAMS'] = os.path.join(wd, 'xtandem.params')
        templates.read_mod_write(app_info, templates.get_tpl_of_class(self), app_info['XTANDEM_PARAMS'])
        app_info['XTANDEM_INPUT'] = os.path.join(wd, 'xtandem.input')
        app_info['XTANDEM_TAXONOMY'] = os.path.join(wd, 'xtandem.taxonomy')
        app_info['XTANDEM_RESULT'] = os.path.join(wd, 'xtandem.result')
        self._write_input_files(app_info)

        #integrated tandem2xml XTANDEM_RESULT conversion
        info[Keys.PEPXML] = os.path.join(wd, 'xtandem.pep.xml')
        command = []
        tpp_dir = info['TPPDIR']
        command.append("{exe} {tandeminput}".format(exe=os.path.join(tpp_dir,tandemexe),tandeminput=app_info['XTANDEM_INPUT']))

        command.append('{exe} {tandemresult} {pepxml} '.format(exe = os.path.join(tpp_dir,tandem2xmlexe),
            tandemresult=app_info['XTANDEM_RESULT'],pepxml=info[Keys.PEPXML]))
        return info, command
Beispiel #2
0
    def prepare_run(self, log, info):
        wd = info[Keys.WORKDIR]

        #add in blast and mzxml2mgf conversion
        omssadbase = os.path.join(wd, os.path.basename(info['DBASE']))
        os.symlink(info['DBASE'], omssadbase)
        mzxmlbase = os.path.basename(info[Keys.MZXML])
        mzxmllink = os.path.join(wd, mzxmlbase)
        mgffile = os.path.join(wd, os.path.splitext(mzxmlbase)[0] + '.mgf')
        os.symlink(info[Keys.MZXML], mzxmllink)

        basename = os.path.splitext(os.path.split(info[Keys.MZXML])[1])[0]
        result = os.path.join(wd, basename+'.pep.xml')
        iresult = os.path.join(wd, basename+'.withRT.pep.xml')
        info[Keys.PEPXML] = iresult

        # need to create a working copy to prevent replacement or generic definitions
        # with app specific definitions
        app_info = info.copy()
        app_info['DBASE'] = omssadbase

        if info['FRAGMASSUNIT'] == 'ppm':
            raise RuntimeError("OMSSA does not support frag mass error unit PPM")

        app_info['USERMODXML'] = os.path.join(wd, 'usermod.xml')
        app_info["STATIC_MODS"], app_info["VARIABLE_MODS"], tpl = genmodstr_to_engine(info["STATIC_MODS"],
                                                                                   info["VARIABLE_MODS"], 'Omssa')
        if app_info['STATIC_MODS']:
            app_info['STATIC_MODS'] = "-mf " + app_info['STATIC_MODS']
        if app_info['VARIABLE_MODS']:
            app_info['VARIABLE_MODS'] = "-mv " + app_info['VARIABLE_MODS']

        open(app_info['USERMODXML'], 'w').write(tpl)
        app_info['ENZYME'], _ = enzymestr_to_engine(info['ENZYME'], 'Omssa')
        mod_template = templates.modify_template(app_info, templates.read_template(templates.get_tpl_of_class(self)))
        # necessary check for the precursor mass unig
        if app_info['PRECMASSUNIT'].lower() == "ppm":
            mod_template += ' -teppm'
            log.debug('added [ -teppm] to modified template because the precursor mass is defined in ppm')

        exe = app_info.get(Keys.EXECUTABLE, 'omssacl')

        #grep to prevent log overflow, InteractParser to add RT to pepXML
        command = "makeblastdb -dbtype prot -in %s && " \
                  "MzXML2Search -mgf %s | grep -v scan && " \
                  "%s %s -fm %s -op %s && " \
                  "InteractParser %s %s -S" % (
                      omssadbase,
                      mzxmllink,
                      exe, mod_template, mgffile, result,
                      iresult, result)
        return info, command
Beispiel #3
0
    def prepare_run(self, log, info):
        wd = info[Keys.WORKDIR]
        basename = os.path.join(
            wd,
            os.path.splitext(os.path.split(info[Keys.MZXML])[1])[0])
        info[Keys.PEPXML] = basename + '.pep.xml'

        # need to create a working copy to prevent replacement or generic definitions
        # with app specific definitions
        app_info = info.copy()

        if info['PRECMASSUNIT'] == 'Da':
            app_info['PRECMASSUNIT'] = '0'
        elif info['PRECMASSUNIT'] == 'ppm':
            app_info['PRECMASSUNIT'] = '2'
        else:
            raise RuntimeError("Precmassunit %s unknown" %
                               info['PRECMASSUNIT'])

        if info['FRAGMASSUNIT'] == 'ppm':
            raise RuntimeError(
                "Comet does not support frag mass error unit PPM")

        if not 0.01 < float(app_info['FRAGMASSERR']) < 1.1:
            log.warn('Very high or low fragmasserror ' +
                     app_info['FRAGMASSERR'])

        app_info["STATIC_MODS"], app_info[
            "VARIABLE_MODS"], _ = genmodstr_to_engine(info["STATIC_MODS"],
                                                      info["VARIABLE_MODS"],
                                                      'Comet')
        app_info['ENZYME'], app_info[
            'NUM_TERM_CLEAVAGES'] = enzymestr_to_engine(
                info['ENZYME'], 'Comet')

        tplfile = os.path.join(wd, "comet.params")
        template = get_tpl_of_class(self)
        read_mod_write(app_info, template, tplfile)

        exe_path = app_info['COMET_DIR']
        exe = app_info['COMET_EXE']

        command = "{exe} -N{basename} -P{tplfile} {mzxml}".format(
            exe=os.path.join(exe_path, exe),
            basename=basename,
            tplfile=tplfile,
            mzxml=info[Keys.MZXML])
        #command = []
        return info, command
Beispiel #4
0
    def prepare_run(self, log, info):
        wd = info[Keys.WORKDIR]
        tandemexe = info.get('TANDEM_EXE')
        tandem2xmlexe = info.get('TANDEM2XML_EXE')

        # need to create a working copy to prevent replacement with app specific definitions
        app_info = info.copy()

        app_info = self._define_score(app_info, log)

        app_info["STATIC_MODS"],
        app_info["VARIABLE_MODS"],
        app_info['TERMINAL_MODS'] = genmodstr_to_engine(
            info["STATIC_MODS"], info["VARIABLE_MODS"], 'XTandem')
        cleavage, enzyme = enzymestr_to_engine(info['ENZYME'], 'XTandem')

        app_info['ENZYME'] = cleavage
        app_info['XTANDEM_SEMI_CLEAVAGE'] = enzyme
        #files required and written
        app_info['XTANDEM_PARAMS'] = os.path.join(wd, 'xtandem.params')
        templates.read_mod_write(app_info, templates.get_tpl_of_class(self),
                                 app_info['XTANDEM_PARAMS'])
        app_info['XTANDEM_INPUT'] = os.path.join(wd, 'xtandem.input')
        app_info['XTANDEM_TAXONOMY'] = os.path.join(wd, 'xtandem.taxonomy')
        app_info['XTANDEM_RESULT'] = os.path.join(wd, 'xtandem.result')
        self._write_input_files(app_info)

        #integrated tandem2xml XTANDEM_RESULT conversion
        info[Keys.PEPXML] = os.path.join(wd, 'xtandem.pep.xml')
        command = []
        tpp_dir = info['TPPDIR']
        command.append("{exe} {tandeminput}".format(
            exe=os.path.join(tpp_dir, tandemexe),
            tandeminput=app_info['XTANDEM_INPUT']))

        command.append('{exe} {tandemresult} {pepxml} '.format(
            exe=os.path.join(tpp_dir, tandem2xmlexe),
            tandemresult=app_info['XTANDEM_RESULT'],
            pepxml=info[Keys.PEPXML]))
        return info, command
Beispiel #5
0
    def prepare_run(self, log, info):
        wd = info[Keys.WORKDIR]
        basename = os.path.join(wd, os.path.splitext(os.path.split(info[Keys.MZXML])[1])[0])
        info[Keys.PEPXML] = basename + ".pep.xml"

        # need to create a working copy to prevent replacement or generic definitions
        # with app specific definitions
        app_info = info.copy()

        if info["PRECMASSUNIT"] == "Da":
            app_info["PRECMASSUNIT"] = "0"
        elif info["PRECMASSUNIT"] == "ppm":
            app_info["PRECMASSUNIT"] = "2"
        else:
            raise RuntimeError("Precmassunit %s unknown" % info["PRECMASSUNIT"])

        if info["FRAGMASSUNIT"] == "ppm":
            raise RuntimeError("Comet does not support frag mass error unit PPM")

        if not 0.01 < float(app_info["FRAGMASSERR"]) < 1.1:
            log.warn("Very high or low fragmasserror " + app_info["FRAGMASSERR"])

        app_info["STATIC_MODS"], app_info["VARIABLE_MODS"], _ = genmodstr_to_engine(
            info["STATIC_MODS"], info["VARIABLE_MODS"], "Comet"
        )
        app_info["ENZYME"], app_info["NUM_TERM_CLEAVAGES"] = enzymestr_to_engine(info["ENZYME"], "Comet")

        tplfile = os.path.join(wd, "comet.params")
        template = get_tpl_of_class(self)
        read_mod_write(app_info, template, tplfile)

        exe_path = app_info["COMET_DIR"]
        exe = app_info["COMET_EXE"]

        command = "{exe} -N{basename} -P{tplfile} {mzxml}".format(
            exe=os.path.join(exe_path, exe), basename=basename, tplfile=tplfile, mzxml=info[Keys.MZXML]
        )
        return info, command
    def prepare_run(self, log, info):
        wd = info[Keys.WORKDIR]
        basename = os.path.splitext(os.path.split(info[Keys.MZXML])[1])[0]
        info[Keys.PEPXML] = os.path.join(
            wd, basename + ".pepXML")  #myrimatch default is pepXML NOT pep.xml

        # need to create a working copy to prevent replacement or generic definitions
        # with app specific definitions
        app_info = info.copy()
        app_info['ENZYME'], app_info[
            'MYRIMATCH_MINTERMINICLEAVAGES'] = enzymestr_to_engine(
                info['ENZYME'], 'Myrimatch')
        app_info["STATIC_MODS"], app_info[
            "VARIABLE_MODS"], _ = genmodstr_to_engine(info["STATIC_MODS"],
                                                      info["VARIABLE_MODS"],
                                                      'Myrimatch')
        if app_info['FRAGMASSUNIT'] == 'Da':
            app_info['FRAGMASSUNIT'] = 'daltons'

        #tpl = os.path.join(wd, 'myrimatch.cfg')
        tpl = 'myrimatch.cfg'
        tplfile = os.path.join(wd, tpl)
        read_mod_write(app_info, get_tpl_of_class(self), tplfile)

        exe_path = app_info['MYRIMATCH_DIR']
        exe = app_info['MYRIMATCH_EXE']
        command = "{exe} -cpus {threads} -cfg {tpl} -workdir {workdir} -ProteinDatabase {dbase} {mzxml}".format(
            exe=os.path.join(exe_path, exe),
            threads=app_info['THREADS'],
            tpl=tpl,
            workdir=app_info[Keys.WORKDIR],
            dbase=app_info['DBASE'],
            mzxml=app_info[Keys.MZXML])
        # update original info object with new keys from working copy
        #info = DictUtils.merge(log, info, app_info, priority='left')
        return info, command