User Tools

Site Tools


surFit Software Documentation

This document is intended for the developers of surfit. This contains technical information on the Scripts and notes. If you want to know how to use surfit, please read the Surfit User Manual.

Repository File Structure

Once a copy of the source has been checked out from the repository, the structure of directories in the surfit software package is as follows:

  • code - Contains the source code of Surfit
  • configuration - Configuration Files
  • docs - Additional Documentation
  • samples - Sample Inputs
  • unitTests - Contains scripts for Regression Tests and Sample Commands for module usage

The code directory contains all source for the surfit scripts and third party software that we're allowed to distribute. The following packages are distributed with surfit:

  • Core Docking Program (C++)
  • Empire (C++)
  • Oscar - Star (C++)
  • Pinup (C++)

The code directory also contains a folder of perl and python scripts that are used to run the docking pipeline, and some tools that are used for data analysis. Lastly, there is a web folder that contains all the code related to the web interface.

In addition to all the code, surfit also uses other third party programs, such as Presto, which are distributed separately and are not included in the package.


Scripts to support installation of Surfit on other Machines is yet to be developed. Subscribe to changes on this page for updated information.



a configuration file can be found in configuration/surfit.conf. More information can be found in the surfit configuration wiki regarding the fields and parameters that can be modified with running surfit.


Surfit is divided into several modules:

  • Docking Module
  • Minimization Module
  • Molecular Dynamics Module
  • Filtering Module
  • Scoring Module
  • Clustering Module

In the python directory, several python wrapper scripts were written to perform the features that are described in each Module. For detailed information on each script, click on the wiki page about that script. The diagram below roughly describes the flow of the Pipeline:


A docking calculation typically begins by invoking the script. The driver script will accept a single-chain receptor and ligand input. The script imports the script, which calculates the surface propensity scores, and then calls the script, which is essentially the docking module.

In surfit, each script can be independently run as a stand alone module (e.g. you can use to calculate the surface propensity of any PDB File). For more information, each python script in the package can be invoked with the - - h argument. All scripts require a configuration file to run in order to correctly set the parameters.

Docking Module

The docking module is a python script that accepts a list of files that is required to perform rigid docking. When run as an independent module, the files are passed as a list. The list is a text file containing the following information:

receptor_pdb: rec.pdb
ligand_pdb: lig.pdb
rec_propensity_file: rec.chg
lig_propensity_file: lig.chg
rec_surface_file: rec.efvet
lig_surface_file: lig.efvet

When invoked from the script, the files are represented in a hash called 'files' as follows:


These files are generated by the script in the docking pipeline. rec_patch_file and lig_patch_file exist when restraints are supplied to the docking calculation.

The docking module performs rigid docking using the C program “dock” in the function “dock”, and then scores the solutions in the function “dockscore”. (for more details on functions in the script, see the script's wiki).

The result is a file which is specified in script as a hash of files, called files['dockscoreout'] which contains rotation information of the solutions, and a file files['binscores'] which is a distribution of scores from the results in the dockscoreout file.

In scoring structures, the script will call the script to generate the PDB Files and predict side chains (if desired) using the program Oscar-Star (distributed with the surfit package as Oscar-iStar in the code directory).

The script will then call the Minimization Module (and Optionally, the Molecular Dynamics, Filtering and Clustering Modules) before proceeding to Scoring. In the Repository file structure, this script is in ../code/python/.

Minimization Module

The minimization module is a script that calls a third-party program Presto. Before Scoring, it is required that the structures are minimized for accurate ranking of the solutions. The script takes a directory of PDBs and runs Presto on each, and stores the result in a new directory.

In the Repository file structure, this script is in ../code/python/minimization/. Several parameters can be set when running this script, which can be set in the arguments:

  • min clash (minimum number of clashes to consider between chains, default: 100)
  • loop limit (Number of minimization steps to perform, default: 2000)
  • radius (Radius for Positional Restraint, default: 5.0)

MD Calculation Module

The MD Calculation Module is a script that also calls Presto. The usage is very similar to the Minimization Module, with additional Parameters. This module is currently being developed. Subscribe to changes on this page for updated information.

Filtering Module

An additional module will be developed to include scoring by Empire. Subscribe to changes on this page for updated information.

Scoring Module

The Scoring Module is a script that calls the oscar scoring program after the PDB Candidate files are minimized (and optionally, filtered and clustered). The script is currently being developed. Subscribe to changes on this page for updated information.

Clustering Module

An additional module will be developed to invoke the C program “clustering” which will cluster Candidate PDB Files in cases that there are too many solutions to consider. The program has two parameters, the NER and RMSD cutoff, and requires an oscar score before running the script.

en/surfit/software_documentation.txt · Last modified: 2014/01/14 10:50 by km