예제 #1
0
 def __init__(self, cmd='molrep', **kwargs):
     self.parameters = [
         Switch(['-h', 'help'], ''),
         Switch(['-i', 'interactive'], ''),
         Option(['-f', 'hklin'], '', equate=False, filename=True),
         Option(['-m', 'xyzin'], '', equate=False, filename=True),
         Option(['-m2', 'xyzin2'], '', equate=False, filename=True),
         Option(['-mx', 'fixed_xyzin'], '', equate=False, filename=True),
         Option(['-s', 'seqin'], '', equate=False, filename=True),
         Option(['-s2', 'seqin2'], '', equate=False, filename=True),
         Option(['-k', 'keyin'], '', equate=False, filename=True),
         Option(['-po', 'out_dir'], '', equate=False),
         Option(['-ps', 'out_scr'], '', equate=False),
     ]
     AbstractCommandline.__init__(self, cmd, **kwargs)
예제 #2
0
파일: dssp.py 프로젝트: fsimkovic/mxkit
 def __init__(self, cmd='dssp', **kwargs):
     self.parameters = [
         Switch(['-v', 'verbose'],
                'Verbose output'),
         Option(['-i', 'input'],
                 "Input structure",
                 equate=False,
                 filename=True,
                 is_required=True),
         Option(['-o', 'output'],
                 "Output DSSP file",
                 equate=False,
                 filename=True,
                 is_required=True),
     ]
     AbstractCommandline.__init__(self, cmd, **kwargs)
예제 #3
0
 def __init__(self, cmd='TMscore', **kwargs):
     self.parameters = [
         Switch([
             '-c', 'complex'
         ], 'Run TM-score to compare two complex structures with multiple chains'
                ),
         Option(['-d', 'norm_scale'],
                'TM-score normalized with an assigned scale d0',
                equate=False),
         Option(['-l', 'norm_length'],
                'TM-score normalized by a specific length',
                equate=False),
         Argument(['model'],
                  "Input model structure",
                  filename=True,
                  is_required=True),
         Argument(['native'],
                  "Input native structure",
                  filename=True,
                  is_required=True),
     ]
     AbstractCommandline.__init__(self, cmd, **kwargs)
예제 #4
0
 def __init__(self, cmd='TMalign', **kwargs):
     self.parameters = [
         Argument(['chain1'],
                  'first PDB structure',
                  filename=True,
                  is_required=True),
         Argument(['chain2'],
                  'second PDB structure',
                  filename=True,
                  is_required=True),
         Option(['-i', 'aln_in'],
                'an alignment specified in fasta file',
                equate=False,
                filename=True),
         Option(['-I', 'aln_out'],
                'stick the alignment to this file',
                equate=False,
                filename=True),
         Option(
             ['-o', 'superposition'],
             "output the superposition to 'TM.sup', 'TM.sup_all' and 'TM.sup_atm'",
             equate=False,
             filename=True),
         Switch(
             ['-a', 'normalized'],
             'TM-score normalized by the average length of two proteins'),
         Option(['-L', 'assigned_length'],
                'TM-score normalized by an assigned length (>L_min)',
                equate=False),
         Option(['-d', 'scale_factor'],
                'TM-score scaled by an assigned d0',
                equate=False),
         Option(['-m', 'rotation_matrix'],
                'output TM-align rotation matrix',
                equate=False,
                filename=True),
     ]
     AbstractCommandline.__init__(self, cmd, **kwargs)
예제 #5
0
    def __init__(self, cmd='maxcluster', **kwargs):
        if not self.options_ok(**kwargs):
            msg = "Unknown combination: Please use one of the following:" \
                  "     -e [file]   PDB experiment" \
                  "     -p [file]   PDB prediction" \
                  " OR" \
                  "     -l [file]   File containing a list of PDB model fragments" \
                  " OR" \
                  "     -e [file]   PDB experiment" \
                  "     -l [file]   File containing a list of PDB model fragments"
            raise RuntimeError(msg)

        self.parameters = [
            Option(['-e', 'pdb_experiment'],
                   'PDB experiment',
                   equate=False,
                   filename=True),
            Option(['-p', 'pdb_prediction'],
                   'PDB prediction',
                   equate=False,
                   filename=True),
            Option(['-l', 'pdb_list'],
                   'File containing a list of PDB model fragments',
                   equate=False,
                   filename=True),

            # OPTIONS
            Option(['-L', 'log_level'],
                   'Log level (default is 4 for single MaxSub, 1 for lists)',
                   equate=False),
            Option(['-d', 'distance_cutoff'],
                   'The distance cut-off for search (default auto-calibrate)',
                   equate=False),
            Option(
                ['-N', 'norm_length'],
                'The normalisation length for TM score (default is length of experiment)',
                equate=False),
            Switch(['-rmsd', 'rmsd'], 'Perform only RMSD fit'),
            Option(['-i', 'maxsubdom_iterations'],
                   'MaxSubDom iterations (default = 1)',
                   equate=False),
            Switch(['-in', 'sequence_independent'],
                   'Sequence independant mode'),

            # CLUSTERING OPTIONS
            Option(['-C', 'cluster_method'], "Cluster method:"
                   "   0 - No clustering"
                   "   1 - Single linkage"
                   "   2 - Average linkage"
                   "   3 - Maximum linkage"
                   "   4 - Neighbour pairs (min size)"
                   "   5 - Neighbour pairs (absolute size)"
                   "(default = 5)",
                   equate=False),
            Option(
                ['-T', 'init_cluster_threshold'],
                'Initial clustering threshold (default RMSD = 4; MaxSub = 0.5)',
                equate=False),
            Option(
                ['-Tm', 'max_cluster_threshold'],
                'Maximum clustering threshold (default RMSD = 8; MaxSub = 0.8)',
                equate=False),
            Option(
                ['-a', 'adj_cluster_threshold'],
                'Clustering threshold adjustment (default RMSD = 0.2; MaxSub = 0.05)',
                equate=False),
            Option(['-is', 'init_cluster_size'],
                   'Initial cluster size (default = 50)',
                   equate=False),
            Option(['-ms', 'min_cluster_size'],
                   'Minimum cluster size (default = 5)',
                   equate=False),
            Option(['-s', 'score_threshold'],
                   '3D-jury score threshold (default = 0.2)',
                   equate=False),
            Option(['-P', 'pair_threshold'],
                   '3D-jury pair threshold (default = 20)',
                   equate=False)
        ]
        AbstractCommandline.__init__(self, cmd, **kwargs)
예제 #6
0
    def __init__(self, cmd='theseus', **kwargs):

        if 'pdb_files' in kwargs and (isinstance(kwargs['pdb_files'], list) or
                                      isinstance(kwargs['pdb_files'], tuple)):
            kwargs['pdb_files'] = " ".join(kwargs['pdb_files'])

        self.parameters = [
            Option(
                ['-a', 'atoms'], "atoms to include in superposition"
                "    0 = alpha carbons and phosphorous atoms"
                "    1 = backbone"
                "    2 = all"
                "    3 = alpha and beta carbons"
                "    4 = all heavy atoms (all but hydrogens)"
                "         or"
                "    a colon-delimited string specifying the atom-types PDB-style"
                "e.g., -a ' CA  : N'"
                "selects the alpha carbons and backone nitrogens",
                equate=False),
            Switch(['-f', 'first_model'],
                   "only read the first model of a multi-model PDB file"),
            Option(['-i', 'niteration'],
                   "maximum iterations {200}",
                   equate=False),
            Switch(['-l', 'least_square'],
                   "superimpose with conventional least squares method"),
            Option(['-s', 'residues_incl'],
                   "residues to select (e.g. -s15-45:50-55) {all}",
                   equate=False),
            Option(['-S', 'residues_excl'],
                   "residues to exclude (e.g. -S15-45:50-55) {none}",
                   equate=False),
            Switch(['-v'
                    'ml_variance_weighting'],
                   "use ML variance weighting (no correlations)"),

            # Input/output options
            Switch(['--amber', 'amber'],
                   "for reading AMBER8 formatted PDB files"),
            Option(
                ['-A', 'alignment'],
                "sequence alignment file to use as a guide (CLUSTAL or A2M format)",
                equate=False,
                filename=True),
            Switch(['-F', 'print_fasta'],
                   "print FASTA files of the sequences in PDB files and quit"),
            Switch([
                '-I', 'no_superposition'
            ], "just calculate statistics for input file (don't superposition)"
                   ),
            Option(
                ['-M', 'sequence_map'],
                "file that maps sequences in the alignment file to PDB files",
                equate=False,
                filename=True),
            Option(['-r', 'root_name'],
                   'root name for output files {theseus}',
                   equare=False),

            # Principal components analysis
            Switch(
                ['-C', 'covariance_matrix'],
                "use covariance matrix for PCA (correlation matrix is default)"
            ),
            Option(['-P', 'principal_components'],
                   "# of principal components to calculate {0}",
                   equate=False),

            # Morphometrics
            Switch(['-d', 'scale_factors'],
                   "calculate scale factors (for morphometrics)"),
            Switch(['-q', 'rohlf_files'],
                   "read and write Rohlf TPS morphometric landmark files"),
            ArgumentList(['pdb_files'],
                         'Input pdb files',
                         filename=True,
                         is_required=True),
        ]
        AbstractCommandline.__init__(self, cmd, **kwargs)