 |
Structural Bioinformatics Library
Template C++ / Python API for developping structural bioinformatics applications.
|
|
Structural Bioinformatics Library
Template C++ / Python API for developping structural bioinformatics applications.
|
Authors: F. Cazals and T. Dreyfus
We consider a structure (molecule, complex) decomposed into units. A unit may be a polypeptide chain, a domain, a set of residues, etc. Our focus is on interactions between these units, and we ascribe such interactions to two categories, referred to as geometric interactions/interfaces and biochemical interactions/interfaces.
Geometric interactions/interfaces. Such interfaces typically correspond to non-covalent interactions between atoms ascribed to units. Typical cases where such interfaces are of interest are:
For each geometric interface between two units, high level information is provided, including (i) the number of particles involved at each interface, (ii) tThe number of connected components i.e. patches of each interface. These pieces of information provide a first indication on the various contacts between the molecules in presence, e.g. to select interfaces to further investigate using the applications of Space_filling_model_interface from Space_filling_model_interface .
Biochemical interactions/interfaces. The focus here is on more local interactions between units, such as disulfide bonds and ionic interactions–see the package Pointwise_interactions.
Applications provided. The applications 
and 
, for Binary Interfaces Finder.
Contacts. Consider a model in a PDB file, consisting of chains made of particles. We assume (details below), that each particle has been assigned a primitive label, as defined in the concept MolecularSystemLabelsTraits. For the program , there is one primitive label per chain, without any hierarchy.
Consider the 
-complex of the solvent accessible representation of the particles of the model–see package Alpha_complex_of_molecular_model.
Our focus is on contacts, which are of two types, bicolor and mediated. In the sequel, we briefly recall the definitions of these concepts, and refer the reader to the package Space_filling_model_interface for more details.
An edge in the alpha complex defines a bicolor contact provided that its endpoints carry two different primitive labels. To define a mediated contact, consider a mediator particle sandwiched between two particles with different primitive labels (i.e, there is an edge from both partners' particles to the mediator's particle). Such a particle induces two mediated contacts, one with each particle carrying a primitive label – see Fig. fig-bif-mediated-contact.
Interfaces. The contacts between partners are edges of the -complex: these edges have a dual face termed Voronoi tile in the associated Voronoi diagram called. The set of all Voronoi tiles involving only bicolor (resp. mediated) contacts is called the bicolor (resp. mediated) interface . The union of bicolor and mediated interfaces of two given partners defines the tricolor interface , plainly called interface if there is no ambiguity.
The program collects all bicolor and mediated contacts in a molecular structure, and groups them by interface. For each interface, two parameters are reported: first, the number of particles involved, and second, the number of connected components.
 |
Voronoi interfaces: bicolor and mediated. This fictitious molecular structure involves two partners A (red) and B (blue) and two water molecules (gray). A and B make one bicolor contact; the water molecule |
This packages hinges on the functionalities from the package Tertiary_quaternary_structure_annotator, so as to report a number of specific interactions between regions in a structure or complex, such as:
This section presents the program , which deals with the case where one unit refers to one polypeptide chain.
Input. A PDB file. Note that works with water molecules that are loaded by default: removing them is done using the options –no-water .
Main options.
is:
makes two mediated contacts.-f string: PDB file of the input molecule
Note that a default radius of 
is added to all atoms to define the Solvent Accessible Model of the input molecule.
Main output. Main output files:
Remarks.
This section presents the program , which deals with the case where one unit refers to a set of residues in a protein.
Input. Running requires two input files:
Main options.
are:-f string: PDB file of the input molecule–domain-labels string: file specifying the domains of the input molecule
Main output.
Comments.
, the labels are defined from the class SBL::Models::Domain_label_traits, which allows a user to specify his own labels. These labels typically define domains within a protein.
The SBL provides VMD and PyMOL plugins to use the programs of Space_filling_model_interface_finder . The plugins are accessible in the Extensions menu of VMD or in the Plugin menu of PyMOL . Upon termination of a calculation launched by the plugin, the following visualizations are available:
A graph, called the Binary Interfaces Graph, representing the binary interfaces found:
Using the notions of bicolor and mediated contacts recalled in the section Prerequisites, assume that
The applications perform two tasks:
See algorithms in the package Pointwise_interactions.
The programs of Space_filling_model_interface_finder described above are based upon generic C++ classes, so that additional versions can easily be developed for protein or nucleic acids, both at atomic or coarse-grain resolution.
In order to derive such versions, there are two important ingredients, that are the workflow class, and its traits class.
T_Space_filling_model_interface_finder_traits:
T_Space_filling_model_interface_finder_workflow:
In the sequel, we study two cases:
#!/usr/bin/python
import re #regular expressions
import sys #misc system
import os
import pdb
import shutil # python 3 only
def find_file_in_output_directory(str, odir):
cmd = "find %s -name *%s" % (odir,str)
return os.popen(cmd).readlines()[0].rstrip()
def run_calculation(pdbid):
#input filename and output directory
pdb_prefix = pdbid.rsplit(".")[0]
ifname = "../../../demos/data/%s" % pdbid
odir = "results-%s" % pdb_prefix
if not os.path.exists(odir): os.system( ("mkdir %s" % odir) )
# check executable exists and is visible
exe = shutil.which("sbl-bif-chainsW-atomic.exe")
print( ("Using executable %s\n" % exe) )
# run command
cmd = "%s -f %s -p 1 --directory %s --verbose --output-prefix --log" % (exe,ifname,odir)
os.system(cmd)
# list output files
ofnames = os.popen( ("ls %s" % odir) ).readlines()
print("\nAll output files are:",ofnames)
# find the lof file and display log file
lfname = find_file_in_output_directory("log.txt", odir)
print("\nLog file is:", lfname)
#log = open(lfname).readlines()
# for line in log: print(line.rstrip())
run_calculation("1vfb.pdb")
The 1vfb file contains three polypeptide chains names A, B, and C.
from IPython.display import Image
def display_graphs(pdbid):
pdb_prefix = pdbid.rsplit(".")[0]
ifname = "../../../demos/data/%s" % pdbid
odir = "results-%s" % pdb_prefix
# find the dot file listing interfaces
of_interf_dot = find_file_in_output_directory("vor_interfaces_graph.dot", odir)
of_interf_xml = find_file_in_output_directory("vor_interfaces_graph.xml", odir)
# plot and display image
of_geom_png = "%s-geom_interfaces.png" % pdb_prefix
cmd = "dot -Tpng %s -o %s" % (of_interf_dot,of_geom_png); os.system(cmd)
print("Interfaces within chains of PDB file:")
img_geom = Image(filename = of_geom_png, width=300, height=300); display(img_geom)
# likewise for biochemical interfaces i.e. S-S bonds and salt bridges
of_biochem_dot = find_file_in_output_directory("biochemical_interfaces_graph.dot", odir)
of_biochem_xml = find_file_in_output_directory("biochemical_interfaces_graph.xml", odir)
# plot and display image
of_biochem_png = "%s-biochem_interfaces.png" % pdb_prefix
cmd = "dot -Tpng %s -o %s" % (of_biochem_dot, of_biochem_png); os.system(cmd)
print("S-S bonds and salt bridges within PDB file:")
img_biochem = Image(filename = of_biochem_png, width=300, height=300); display(img_biochem)
display_graphs("1vfb.pdb")
For the graph of interfaces:
For the graph of S-S bonds and salt bridges: no relevant information here.
The following example is quite interesting: as a complete immunoglobulin, we investigate the contacts between the four chains, from a geometric standpoint as well as in terms of S-S bonds and salt bridges
run_calculation("1igt.pdb")
display_graphs("1igt.pdb")
The graph of interfaces illustrates the contacts between the heavy and light chains of the IG.
The graph of S-S bonds illustrates disulfide bonds found across the chains. S-S bonds within a chain can also be reported with the option --internal, as illustrated below.
(left) The structure involves four chains. Note in particular the 3 disulfides bonds connecting the two heavy chains (right) The graph produced, with edges counting disulfide bonds and salt bridges. Note that there is a total of 17 / 17 S-S bonds and 18 salt bridges.
display(Image(filename ="fig/1igt-biochem-annotations--montage.png", width=500, height=500));
This more complex example involves 16 subunits.
run_calculation("4D10.pdb")
display_graphs("4D10.pdb")
As can be seen, there are many more interfaces and biochemical features of interest. A full description of the findinds is reported in the xml files dumped into the results directory. Such files should be parsed with PALSE, see https://sbl.inria.fr/doc/PALSE-user-manual.html
Recall that class II fusogens act as trimers. Assume that a decomposition of a monomer into domains has been provided using labels. All contacts between such domains are easily infered.
#input filename and output directory
pdbid = "4ojc--EFF1-trimer.pdb"
pdb_prefix = pdbid.rsplit(".")[0]
ifname = "../../../demos/data/4ojc--EFF1-trimer.pdb"
domain_labels = "../../../demos/data/4ojc--EFF1-trimer-partners.txt"
odir = "results-%s" % pdb_prefix
if not os.path.exists(odir): os.system( ("mkdir %s" % odir) )
# check executable exists and is visible
exe = shutil.which("sbl-bif-domainsW-atomic.exe")
print( ("Using executable %s\n" % exe) )
# run command
cmd = "%s -f %s --domain-labels %s --directory %s --verbose --output-prefix --log"\
% (exe, ifname,domain_labels, odir)
print("Running ",cmd)
os.system(cmd)
display_graphs("4ojc--EFF1-trimer.pdb")
As for the previous example, an automatic processing of the xml files delivered is in order.
1.9.1