PDB to NERDSS Converter Tutorial

This notebook shows how to use the modules in ionerdss.model_setup to:

  1. Read or download a PDB/CIF file.

  2. Detect binding interfaces.

  3. Regularize a coarse‐grained model for NERDSS simulation.

Make sure your ionerdss package is either installed or that the ionerdss folder is on sys.path.

[1]:

import sys
import os

# Go two levels up from docs/source/ to reach the project root
sys.path.insert(0, os.path.abspath('../../'))

from ionerdss.model_setup.protein_model import ProteinModel

print('Imports successful!')

Imports successful!

1. Create a ProteinModel

Below, we demonstrate how to create a ProteinModel from a 4-letter PDB ID / PDB file / CIF file.

[2]:

pdb_id = '../../data/7uhy.cif'
model = ProteinModel(pdb_id)
print('ProteinModel created!')

repeated chains identify finished using the CIF file header: chain ID to molecular type mapping:
{'A': 'A', 'B': 'A', 'A-2': 'A', 'B-2': 'A', 'C': 'B', 'C-2': 'B', 'D': 'C', 'D-2': 'C', 'E': 'D', 'F': 'D', 'G': 'D', 'E-2': 'D', 'F-2': 'D', 'G-2': 'D', 'H': 'E', 'H-2': 'E'}
homogolous chains groups:
[['A', 'B', 'A-2', 'B-2'], ['C', 'C-2'], ['D', 'D-2'], ['E', 'F', 'G', 'E-2', 'F-2', 'G-2'], ['H', 'H-2']]
ProteinModel created!

[ ]:

try:
    import nglview as nv

    view = nv.show_file(pdb_id)
    view
except ImportError:
    print("nglview is not installed. Please install it using: %pip install nglview")
    print("This will not display the 3D structure of the protein model in the notebook.")

2. Detect Interfaces

We can now detect binding interfaces in the structure.

  • cutoff=0.35 is the maximum distance (in nm) for atom contacts.

  • residue_cutoff=3 means we need at least 3 contacting residues.

[4]:

model.verbose = False  # set to True for print interfaces
model.detect_interfaces(cutoff=0.35, residue_cutoff=3)
print('Interfaces detected!')

Interfaces detected!

3. Visualize the Original Coarse‐Grained Structure

This uses Matplotlib’s 3D capabilities to show each chain’s Center of Mass and Interface points.

[5]:

%matplotlib widget

model.plot_original_coarse_grained_structure()

[ ]:

model.save_original_coarse_grained_structure(
    output_cif='coarse_grained.cif',
    pymol_script='visualize_coarse.pml'
)
print('Coarse-grained structure saved, along with a PyMOL script!')
print('You can visualize the coarse-grained structure by running:')
print('pymol visualize_coarse.pml')

4. Regularize & Build Reactions

If the structure has repeated chains, we can align them so they share the same geometry. This also sets up Reaction objects if two chains can bind.

[6]:

model.regularize_molecules(dist_thresh_intra=3.5, dist_thresh_inter=3.5, angle_thresh=25)

print('After regularization:')
model.plot_regularized_structure()

Start parsing chain group / molecule template ['A', 'A-2', 'B', 'B-2']
New mol template A is created.
Start parsing chain / molecule A
New molecule A is created.
Parsing the interface C for molecule A; its binding partner is molecule C via its interface A
new mol template B created for molecule C.
New molecule C is created.
Parsing signature: {'dA': np.float32(46.377213), 'dB': np.float32(42.58677), 'dAB': np.float32(3.2075667), 'thetaA': np.float64(122.37866696224347), 'thetaB': np.float64(151.6661567577198)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(42.58677), 'dB': np.float32(46.377213), 'dAB': np.float32(3.2075667), 'thetaA': np.float64(151.6661567577198), 'thetaB': np.float64(122.37866696224347)} is also added to the list.
Creating new interface C for molecule A
Creating new interface A for partner molecule C
Parsing the interface E for molecule A; its binding partner is molecule E via its interface A
new mol template D created for molecule E.
New molecule E is created.
Parsing signature: {'dA': np.float32(6.9757624), 'dB': np.float32(11.797143), 'dAB': np.float32(6.552778), 'thetaA': np.float64(101.91672103215576), 'thetaB': np.float64(69.55845182655408)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(11.797143), 'dB': np.float32(6.9757624), 'dAB': np.float32(6.552778), 'thetaA': np.float64(69.55845182655408), 'thetaB': np.float64(101.91672103215576)} is also added to the list.
Creating new interface E for molecule A
Creating new interface A for partner molecule E
Parsing the interface B-2 for molecule A; its binding partner is molecule B-2 via its interface A
molecule B-2 already has its template created.
New molecule B-2 is created.
Parsing signature: {'dA': np.float32(48.63179), 'dB': np.float32(48.046413), 'dAB': np.float32(6.377065), 'thetaA': np.float64(56.911159385333164), 'thetaB': np.float64(39.00604845718942)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(48.046413), 'dB': np.float32(48.63179), 'dAB': np.float32(6.377065), 'thetaA': np.float64(39.00604845718942), 'thetaB': np.float64(56.911159385333164)} is also added to the list.
Creating new interface B-2 for molecule A
Creating new interface A for partner molecule B-2
Start parsing chain / molecule A-2
New molecule A-2 is created.
Parsing the interface B for molecule A-2; its binding partner is molecule B via its interface A-2
molecule B already has its template created.
New molecule B is created.
Parsing signature: {'dA': np.float32(48.632126), 'dB': np.float32(48.045746), 'dAB': np.float32(6.377109), 'thetaA': np.float64(56.91080883635533), 'thetaB': np.float64(39.005229134269506)}
this is an existing signature. using the existing interface template.
using A - A1
using A - A1
Creating new interface B for molecule A-2
Creating new interface A-2 for partner molecule B
Parsing the interface E-2 for molecule A-2; its binding partner is molecule E-2 via its interface A-2
molecule E-2 already has its template created.
New molecule E-2 is created.
Parsing signature: {'dA': np.float32(6.9752293), 'dB': np.float32(11.797252), 'dAB': np.float32(6.5527625), 'thetaA': np.float64(101.91699153171747), 'thetaB': np.float64(69.55871059284398)}
this is an existing signature. using the existing interface template.
using A - D1
using D - A1
Creating new interface E-2 for molecule A-2
Creating new interface A-2 for partner molecule E-2
Parsing the interface C-2 for molecule A-2; its binding partner is molecule C-2 via its interface A-2
molecule C-2 already has its template created.
New molecule C-2 is created.
Parsing signature: {'dA': np.float32(46.37672), 'dB': np.float32(42.586582), 'dAB': np.float32(3.2075477), 'thetaA': np.float64(122.37822214601604), 'thetaB': np.float64(151.66650934452394)}
this is an existing signature. using the existing interface template.
using A - B1
using B - A1
Creating new interface C-2 for molecule A-2
Creating new interface A-2 for partner molecule C-2
Start parsing chain / molecule B
This is an existing molecule B
Parsing the interface F for molecule B; its binding partner is molecule F via its interface B
molecule F already has its template created.
New molecule F is created.
Parsing signature: {'dA': np.float32(7.613407), 'dB': np.float32(12.652363), 'dAB': np.float32(4.5805655), 'thetaA': np.float64(135.86945020954346), 'thetaB': np.float64(45.22401784060494)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(12.652363), 'dB': np.float32(7.613407), 'dAB': np.float32(4.5805655), 'thetaA': np.float64(45.22401784060494), 'thetaB': np.float64(135.86945020954346)} is also added to the list.
Creating new interface F for molecule B
Creating new interface B for partner molecule F
Parsing the interface D for molecule B; its binding partner is molecule D via its interface B
new mol template C created for molecule D.
New molecule D is created.
Parsing signature: {'dA': np.float32(41.948658), 'dB': np.float32(26.3451), 'dAB': np.float32(2.1271687), 'thetaA': np.float64(148.5027961981794), 'thetaB': np.float64(124.85481701027788)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(26.3451), 'dB': np.float32(41.948658), 'dAB': np.float32(2.1271687), 'thetaA': np.float64(124.85481701027788), 'thetaB': np.float64(148.5027961981794)} is also added to the list.
Creating new interface D for molecule B
Creating new interface B for partner molecule D
Parsing the interface A-2 for molecule B; its binding partner is molecule A-2 via its interface B
molecule A-2 already has its template created.
molecule A-2 is already created.
Parsing signature: {'dA': np.float32(48.045746), 'dB': np.float32(48.632126), 'dAB': np.float32(6.377109), 'thetaA': np.float64(39.005229134269506), 'thetaB': np.float64(56.91080883635533)}
this is an existing signature. using the existing interface template.
using A - A1
using A - A1
Interface A-2 already exists for molecule B
Interface B already exists for molecule A-2
Start parsing chain / molecule B-2
This is an existing molecule B-2
Parsing the interface A for molecule B-2; its binding partner is molecule A via its interface B-2
molecule A already has its template created.
molecule A is already created.
Parsing signature: {'dA': np.float32(48.046413), 'dB': np.float32(48.63179), 'dAB': np.float32(6.377065), 'thetaA': np.float64(39.00604845718942), 'thetaB': np.float64(56.911159385333164)}
this is an existing signature. using the existing interface template.
using A - A1
using A - A1
Interface A already exists for molecule B-2
Interface B-2 already exists for molecule A
Parsing the interface F-2 for molecule B-2; its binding partner is molecule F-2 via its interface B-2
molecule F-2 already has its template created.
New molecule F-2 is created.
Parsing signature: {'dA': np.float32(7.6127915), 'dB': np.float32(12.65232), 'dAB': np.float32(4.580552), 'thetaA': np.float64(135.87092162762914), 'thetaB': np.float64(45.22323365857926)}
this is an existing signature. using the existing interface template.
using A - D2
using D - A2
Creating new interface F-2 for molecule B-2
Creating new interface B-2 for partner molecule F-2
Parsing the interface D-2 for molecule B-2; its binding partner is molecule D-2 via its interface B-2
molecule D-2 already has its template created.
New molecule D-2 is created.
Parsing signature: {'dA': np.float32(41.94855), 'dB': np.float32(26.34492), 'dAB': np.float32(2.1271708), 'thetaA': np.float64(148.50359367301309), 'thetaB': np.float64(124.85621535003247)}
this is an existing signature. using the existing interface template.
using A - C1
using C - A2
Creating new interface D-2 for molecule B-2
Creating new interface B-2 for partner molecule D-2
Start parsing chain group / molecule template ['C', 'C-2']
This is an existed mol template B
Start parsing chain / molecule C
This is an existing molecule C
Parsing the interface A for molecule C; its binding partner is molecule A via its interface C
molecule A already has its template created.
molecule A is already created.
Parsing signature: {'dA': np.float32(42.58677), 'dB': np.float32(46.377213), 'dAB': np.float32(3.2075667), 'thetaA': np.float64(151.6661567577198), 'thetaB': np.float64(122.37866696224347)}
this is an existing signature. using the existing interface template.
using B - A1
using A - B1
Interface A already exists for molecule C
Interface C already exists for molecule A
Parsing the interface G for molecule C; its binding partner is molecule G via its interface C
molecule G already has its template created.
New molecule G is created.
Parsing signature: {'dA': np.float32(18.607681), 'dB': np.float32(9.386041), 'dAB': np.float32(3.200052), 'thetaA': np.float64(80.69197123111742), 'thetaB': np.float64(53.99981062989752)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(9.386041), 'dB': np.float32(18.607681), 'dAB': np.float32(3.200052), 'thetaA': np.float64(53.99981062989752), 'thetaB': np.float64(80.69197123111742)} is also added to the list.
Creating new interface G for molecule C
Creating new interface C for partner molecule G
Parsing the interface D for molecule C; its binding partner is molecule D via its interface C
molecule D already has its template created.
molecule D is already created.
Parsing signature: {'dA': np.float32(54.41141), 'dB': np.float32(25.676706), 'dAB': np.float32(6.781969), 'thetaA': np.float64(65.73937106625195), 'thetaB': np.float64(33.492385898921654)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(25.676706), 'dB': np.float32(54.41141), 'dAB': np.float32(6.781969), 'thetaA': np.float64(33.492385898921654), 'thetaB': np.float64(65.73937106625195)} is also added to the list.
Creating new interface D for molecule C
Creating new interface C for partner molecule D
Start parsing chain / molecule C-2
This is an existing molecule C-2
Parsing the interface G-2 for molecule C-2; its binding partner is molecule G-2 via its interface C-2
molecule G-2 already has its template created.
New molecule G-2 is created.
Parsing signature: {'dA': np.float32(18.607204), 'dB': np.float32(9.386181), 'dAB': np.float32(3.200033), 'thetaA': np.float64(80.6909157279511), 'thetaB': np.float64(53.99857377953435)}
this is an existing signature. using the existing interface template.
using B - D1
using D - B1
Creating new interface G-2 for molecule C-2
Creating new interface C-2 for partner molecule G-2
Parsing the interface A-2 for molecule C-2; its binding partner is molecule A-2 via its interface C-2
molecule A-2 already has its template created.
molecule A-2 is already created.
Parsing signature: {'dA': np.float32(42.586582), 'dB': np.float32(46.37672), 'dAB': np.float32(3.2075477), 'thetaA': np.float64(151.66650934452394), 'thetaB': np.float64(122.37822214601604)}
this is an existing signature. using the existing interface template.
using B - A1
using A - B1
Interface A-2 already exists for molecule C-2
Interface C-2 already exists for molecule A-2
Parsing the interface D-2 for molecule C-2; its binding partner is molecule D-2 via its interface C-2
molecule D-2 already has its template created.
molecule D-2 is already created.
Parsing signature: {'dA': np.float32(54.411045), 'dB': np.float32(25.676828), 'dAB': np.float32(6.781994), 'thetaA': np.float64(65.73949468127604), 'thetaB': np.float64(33.49221261451965)}
this is an existing signature. using the existing interface template.
using B - C1
using C - B1
Creating new interface D-2 for molecule C-2
Creating new interface C-2 for partner molecule D-2
Start parsing chain group / molecule template ['D', 'D-2']
This is an existed mol template C
Start parsing chain / molecule D
This is an existing molecule D
Parsing the interface B for molecule D; its binding partner is molecule B via its interface D
molecule B already has its template created.
molecule B is already created.
Parsing signature: {'dA': np.float32(26.3451), 'dB': np.float32(41.948658), 'dAB': np.float32(2.1271687), 'thetaA': np.float64(124.85481701027788), 'thetaB': np.float64(148.5027961981794)}
this is an existing signature. using the existing interface template.
using C - A2
using A - C1
Interface B already exists for molecule D
Interface D already exists for molecule B
Parsing the interface C for molecule D; its binding partner is molecule C via its interface D
molecule C already has its template created.
molecule C is already created.
Parsing signature: {'dA': np.float32(25.676706), 'dB': np.float32(54.41141), 'dAB': np.float32(6.781969), 'thetaA': np.float64(33.492385898921654), 'thetaB': np.float64(65.73937106625195)}
this is an existing signature. using the existing interface template.
using C - B1
using B - C1
Interface C already exists for molecule D
Interface D already exists for molecule C
Parsing the interface H for molecule D; its binding partner is molecule H via its interface D
new mol template E created for molecule H.
New molecule H is created.
Parsing signature: {'dA': np.float32(32.076443), 'dB': np.float32(9.301221), 'dAB': np.float32(1.0779481), 'thetaA': np.float64(143.9211393734843), 'thetaB': np.float64(95.35108819925378)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(9.301221), 'dB': np.float32(32.076443), 'dAB': np.float32(1.0779481), 'thetaA': np.float64(95.35108819925378), 'thetaB': np.float64(143.9211393734843)} is also added to the list.
Creating new interface H for molecule D
Creating new interface D for partner molecule H
Parsing the interface G for molecule D; its binding partner is molecule G via its interface D
molecule G already has its template created.
molecule G is already created.
Parsing signature: {'dA': np.float32(34.45588), 'dB': np.float32(25.684935), 'dAB': np.float32(7.688339), 'thetaA': np.float64(20.665825070595513), 'thetaB': np.float64(16.843049772735625)}
this is a new signature. added to list.
the conjugated signature: {'dA': np.float32(25.684935), 'dB': np.float32(34.45588), 'dAB': np.float32(7.688339), 'thetaA': np.float64(16.843049772735625), 'thetaB': np.float64(20.665825070595513)} is also added to the list.
Creating new interface G for molecule D
Creating new interface D for partner molecule G
Start parsing chain / molecule D-2
This is an existing molecule D-2
Parsing the interface B-2 for molecule D-2; its binding partner is molecule B-2 via its interface D-2
molecule B-2 already has its template created.
molecule B-2 is already created.
Parsing signature: {'dA': np.float32(26.34492), 'dB': np.float32(41.94855), 'dAB': np.float32(2.1271708), 'thetaA': np.float64(124.85621535003247), 'thetaB': np.float64(148.50359367301309)}
this is an existing signature. using the existing interface template.
using C - A2
using A - C1
Interface B-2 already exists for molecule D-2
Interface D-2 already exists for molecule B-2
Parsing the interface H-2 for molecule D-2; its binding partner is molecule H-2 via its interface D-2
molecule H-2 already has its template created.
New molecule H-2 is created.
Parsing signature: {'dA': np.float32(32.076633), 'dB': np.float32(9.301207), 'dAB': np.float32(1.0779499), 'thetaA': np.float64(143.92194545970375), 'thetaB': np.float64(95.3514620740463)}
this is an existing signature. using the existing interface template.
using C - E1
using E - C1
Creating new interface H-2 for molecule D-2
Creating new interface D-2 for partner molecule H-2
Parsing the interface G-2 for molecule D-2; its binding partner is molecule G-2 via its interface D-2
molecule G-2 already has its template created.
molecule G-2 is already created.
Parsing signature: {'dA': np.float32(34.456055), 'dB': np.float32(25.684738), 'dAB': np.float32(7.688359), 'thetaA': np.float64(20.6654670271735), 'thetaB': np.float64(16.8425429540915)}
this is an existing signature. using the existing interface template.
using C - D1
using D - C1
Creating new interface G-2 for molecule D-2
Creating new interface D-2 for partner molecule G-2
Parsing the interface C-2 for molecule D-2; its binding partner is molecule C-2 via its interface D-2
molecule C-2 already has its template created.
molecule C-2 is already created.
Parsing signature: {'dA': np.float32(25.676828), 'dB': np.float32(54.411045), 'dAB': np.float32(6.781994), 'thetaA': np.float64(33.49221261451965), 'thetaB': np.float64(65.73949468127604)}
this is an existing signature. using the existing interface template.
using C - B1
using B - C1
Interface C-2 already exists for molecule D-2
Interface D-2 already exists for molecule C-2
Start parsing chain group / molecule template ['E', 'E-2', 'F', 'F-2', 'G', 'G-2']
This is an existed mol template D
Start parsing chain / molecule E
This is an existing molecule E
Parsing the interface A for molecule E; its binding partner is molecule A via its interface E
molecule A already has its template created.
molecule A is already created.
Parsing signature: {'dA': np.float32(11.797143), 'dB': np.float32(6.9757624), 'dAB': np.float32(6.552778), 'thetaA': np.float64(69.55845182655408), 'thetaB': np.float64(101.91672103215576)}
this is an existing signature. using the existing interface template.
using D - A1
using A - D1
Interface A already exists for molecule E
Interface E already exists for molecule A
Start parsing chain / molecule E-2
This is an existing molecule E-2
Parsing the interface A-2 for molecule E-2; its binding partner is molecule A-2 via its interface E-2
molecule A-2 already has its template created.
molecule A-2 is already created.
Parsing signature: {'dA': np.float32(11.797252), 'dB': np.float32(6.9752293), 'dAB': np.float32(6.5527625), 'thetaA': np.float64(69.55871059284398), 'thetaB': np.float64(101.91699153171747)}
this is an existing signature. using the existing interface template.
using D - A1
using A - D1
Interface A-2 already exists for molecule E-2
Interface E-2 already exists for molecule A-2
Start parsing chain / molecule F
This is an existing molecule F
Parsing the interface B for molecule F; its binding partner is molecule B via its interface F
molecule B already has its template created.
molecule B is already created.
Parsing signature: {'dA': np.float32(12.652363), 'dB': np.float32(7.613407), 'dAB': np.float32(4.5805655), 'thetaA': np.float64(45.22401784060494), 'thetaB': np.float64(135.86945020954346)}
this is an existing signature. using the existing interface template.
using D - A2
using A - D2
Interface B already exists for molecule F
Interface F already exists for molecule B
Start parsing chain / molecule F-2
This is an existing molecule F-2
Parsing the interface B-2 for molecule F-2; its binding partner is molecule B-2 via its interface F-2
molecule B-2 already has its template created.
molecule B-2 is already created.
Parsing signature: {'dA': np.float32(12.65232), 'dB': np.float32(7.6127915), 'dAB': np.float32(4.580552), 'thetaA': np.float64(45.22323365857926), 'thetaB': np.float64(135.87092162762914)}
this is an existing signature. using the existing interface template.
using D - A2
using A - D2
Interface B-2 already exists for molecule F-2
Interface F-2 already exists for molecule B-2
Start parsing chain / molecule G
This is an existing molecule G
Parsing the interface C for molecule G; its binding partner is molecule C via its interface G
molecule C already has its template created.
molecule C is already created.
Parsing signature: {'dA': np.float32(9.386041), 'dB': np.float32(18.607681), 'dAB': np.float32(3.200052), 'thetaA': np.float64(53.99981062989752), 'thetaB': np.float64(80.69197123111742)}
this is an existing signature. using the existing interface template.
using D - B1
using B - D1
Interface C already exists for molecule G
Interface G already exists for molecule C
Parsing the interface D for molecule G; its binding partner is molecule D via its interface G
molecule D already has its template created.
molecule D is already created.
Parsing signature: {'dA': np.float32(25.684935), 'dB': np.float32(34.45588), 'dAB': np.float32(7.688339), 'thetaA': np.float64(16.843049772735625), 'thetaB': np.float64(20.665825070595513)}
this is an existing signature. using the existing interface template.
using D - C1
using C - D1
Interface D already exists for molecule G
Interface G already exists for molecule D
Start parsing chain / molecule G-2
This is an existing molecule G-2
Parsing the interface C-2 for molecule G-2; its binding partner is molecule C-2 via its interface G-2
molecule C-2 already has its template created.
molecule C-2 is already created.
Parsing signature: {'dA': np.float32(9.386181), 'dB': np.float32(18.607204), 'dAB': np.float32(3.200033), 'thetaA': np.float64(53.99857377953435), 'thetaB': np.float64(80.6909157279511)}
this is an existing signature. using the existing interface template.
using D - B1
using B - D1
Interface C-2 already exists for molecule G-2
Interface G-2 already exists for molecule C-2
Parsing the interface D-2 for molecule G-2; its binding partner is molecule D-2 via its interface G-2
molecule D-2 already has its template created.
molecule D-2 is already created.
Parsing signature: {'dA': np.float32(25.684738), 'dB': np.float32(34.456055), 'dAB': np.float32(7.688359), 'thetaA': np.float64(16.8425429540915), 'thetaB': np.float64(20.6654670271735)}
this is an existing signature. using the existing interface template.
using D - C1
using C - D1
Interface D-2 already exists for molecule G-2
Interface G-2 already exists for molecule D-2
Start parsing chain group / molecule template ['H', 'H-2']
This is an existed mol template E
Start parsing chain / molecule H
This is an existing molecule H
Parsing the interface D for molecule H; its binding partner is molecule D via its interface H
molecule D already has its template created.
molecule D is already created.
Parsing signature: {'dA': np.float32(9.301221), 'dB': np.float32(32.076443), 'dAB': np.float32(1.0779481), 'thetaA': np.float64(95.35108819925378), 'thetaB': np.float64(143.9211393734843)}
this is an existing signature. using the existing interface template.
using E - C1
using C - E1
Interface D already exists for molecule H
Interface H already exists for molecule D
Start parsing chain / molecule H-2
This is an existing molecule H-2
Parsing the interface D-2 for molecule H-2; its binding partner is molecule D-2 via its interface H-2
molecule D-2 already has its template created.
molecule D-2 is already created.
Parsing signature: {'dA': np.float32(9.301207), 'dB': np.float32(32.076633), 'dAB': np.float32(1.0779499), 'thetaA': np.float64(95.3514620740463), 'thetaB': np.float64(143.92194545970375)}
this is an existing signature. using the existing interface template.
using E - C1
using C - E1
Interface D-2 already exists for molecule H-2
Interface H-2 already exists for molecule D-2
Reaction:
A(C) + C(A) <-> A(C!1).C(A!1)
Angles:
['1.005682', '0.494519', '-0.287440', '-2.549532', '-2.656024']
Sigma:
3.2075667
c1:
[265.0377  238.84146 186.50989]
p1:
[254.24953 281.45352 201.2975 ]
c2:
[251.57582 306.49225 232.10927]
p2:
[255.19028 280.86673 198.28766]
My Reaction Template:
A(B1, C1) + B(A1) <-> A(B1!1, C1).B(A1!1)
Template Angles:
['1.005682', '0.494519', '-0.287440', '-2.549532', '-2.656024']
Template Sigma:
3.2075667
Reaction:
A(E) + E(A) <-> A(E!1).E(A!1)
Angles:
['1.362810', '1.927569', '0.403976', '2.978093', '-1.907003']
Sigma:
6.552778
c1:
[265.0377  238.84146 186.50989]
p1:
[261.54587 244.74207 187.79492]
c2:
[263.9826  250.82404 173.89598]
p2:
[259.50116 243.24866 181.7511 ]
My Reaction Template:
A(D1, D2, C1) + D(A1, A2, B1, C1) <-> A(D1!1, D2, C1).D(A1!1, A2, B1, C1)
Template Angles:
['1.362810', '1.927569', '0.403976', '2.978093', '-1.907003']
Template Sigma:
6.552778
Reaction:
A(B-2) + B-2(A) <-> A(B-2!1).B-2(A!1)
Angles:
['2.143179', '2.558326', '-1.782555', '-1.968693', '-0.198659']
Sigma:
8.046921
c1:
[265.0377  238.84146 186.50989]
p1:
[294.77118 216.4574  217.81363]
c2:
[257.0334  178.82031 233.38245]
p2:
[292.72736 209.71826 221.70718]
My Reaction Template:
A(A1) + A(A1) <-> A(A1!1).A(A1!1)
Template Angles:
['2.143179', '2.558326', '-1.782555', '-1.968693', '-0.198659']
Template Sigma:
8.046921
Reaction:
A-2(B) + B(A-2) <-> A-2(B!1).B(A-2!1)
Angles:
['2.140987', '2.560413', '-1.780219', '-1.963620', '-0.204211']
Sigma:
8.038677
c1:
[154.36737 180.56342 186.50989]
p1:
[124.63379 202.9475  217.81357]
c2:
[162.3722  240.58527 233.38223]
p2:
[126.68524 209.6882  221.68329]
My Reaction Template:
A(A1) + A(A1) <-> A(A1!1).A(A1!1)
Template Angles:
['2.143179', '2.558326', '-1.782555', '-1.968693', '-0.198659']
Template Sigma:
8.046921
Reaction:
A-2(E-2) + E-2(A-2) <-> A-2(E-2!1).E-2(A-2!1)
Angles:
['1.362781', '1.927546', '0.403989', '2.978116', '-1.907012']
Sigma:
6.552831
c1:
[154.36737 180.56342 186.50989]
p1:
[157.85919 174.66281 187.79492]
c2:
[155.42245 168.58104 173.89598]
p2:
[159.90387 176.15643 181.75108]
My Reaction Template:
A(D1, D2, C1) + D(A1, A2, B1, C1) <-> A(D1!1, D2, C1).D(A1!1, A2, B1, C1)
Template Angles:
['1.362810', '1.927569', '0.403976', '2.978093', '-1.907003']
Template Sigma:
6.552778
Reaction:
A-2(C-2) + C-2(A-2) <-> A-2(C-2!1).C-2(A-2!1)
Angles:
['1.005673', '0.494496', '-0.287400', '-2.549588', '-2.656055']
Sigma:
3.2074935
c1:
[154.36737 180.56342 186.50989]
p1:
[165.15544 137.95135 201.2975 ]
c2:
[167.82928 112.9126  232.10927]
p2:
[164.21481 138.53818 198.2877 ]
My Reaction Template:
A(B1, C1) + B(A1) <-> A(B1!1, C1).B(A1!1)
Template Angles:
['1.005682', '0.494519', '-0.287440', '-2.549532', '-2.656024']
Template Sigma:
3.2075667
Reaction:
B(F) + F(B) <-> B(F!1).F(B!1)
Angles:
['0.755718', '1.860954', '-1.707306', '-0.791969', '1.559477']
Sigma:
5.9448433
c1:
[162.3722  240.58527 233.38223]
p1:
[167.93103 241.73257 228.30814]
c2:
[167.53372 251.10156 240.57709]
p2:
[163.3157  244.81378 230.44029]
My Reaction Template:
A(D2, D1) + D(A2, A1, B1, C1) <-> A(D2!1, D1).D(A2!1, A1, B1, C1)
Template Angles:
['0.755718', '1.860954', '-1.707306', '-0.791969', '1.559477']
Template Sigma:
5.9448433
Reaction:
B(D) + D(B) <-> B(D!1).D(B!1)
Angles:
['1.381483', '0.464659', '-1.889826', '2.306218', '-2.697474']
Sigma:
2.8676946
c1:
[162.3722  240.58527 233.38223]
p1:
[160.84015 278.48657 215.47043]
c2:
[177.9324  289.0191  202.65912]
p2:
[158.06284 278.04077 216.02852]
My Reaction Template:
A(C1, B1, D1) + C(A2) <-> A(C1!1, B1, D1).C(A2!1)
Template Angles:
['1.381483', '0.464659', '-1.889826', '2.306218', '-2.697474']
Template Sigma:
2.8676946
Reaction:
B-2(F-2) + F-2(B-2) <-> B-2(F-2!1).F-2(B-2!1)
Angles:
['0.756121', '1.861579', '-1.706619', '-0.791223', '1.559194']
Sigma:
5.945965
c1:
[257.0334  178.82031 233.38245]
p1:
[251.4759  177.67578 228.30621]
c2:
[251.87115 168.30333 240.57712]
p2:
[256.08896 174.5897  230.43938]
My Reaction Template:
A(D2, D1) + D(A2, A1, B1, C1) <-> A(D2!1, D1).D(A2!1, A1, B1, C1)
Template Angles:
['0.755718', '1.860954', '-1.707306', '-0.791969', '1.559477']
Template Sigma:
5.9448433
Reaction:
B-2(D-2) + D-2(B-2) <-> B-2(D-2!1).D-2(B-2!1)
Angles:
['1.381706', '0.462327', '-1.884084', '2.293813', '-2.707834']
Sigma:
2.8679001
c1:
[257.0334  178.82031 233.38245]
p1:
[258.56647 140.92635 215.45522]
c2:
[241.47261 130.38583 202.65912]
p2:
[261.34216 141.36417 216.02852]
My Reaction Template:
A(C1, B1, D1) + C(A2) <-> A(C1!1, B1, D1).C(A2!1)
Template Angles:
['1.381483', '0.464659', '-1.889826', '2.306218', '-2.697474']
Template Sigma:
2.8676946
Reaction:
C(G) + G(C) <-> C(G!1).G(C!1)
Angles:
['1.774031', '2.146613', '-1.242162', '-1.421457', '0.373421']
Sigma:
2.8271708
c1:
[251.57582 306.49225 232.10927]
p1:
[235.5489  297.20303 230.35022]
c2:
[236.89151 307.03363 225.19797]
p2:
[233.81628 299.228   229.40659]
My Reaction Template:
B(D1) + D(B1, A1, A2) <-> B(D1!1).D(B1!1, A1, A2)
Template Angles:
['1.774031', '2.146613', '-1.242162', '-1.421457', '0.373421']
Template Sigma:
2.8271708
Reaction:
C(D) + D(C) <-> C(D!1).D(C!1)
Angles:
['1.994224', '2.557040', '-2.968996', '0.028420', '2.945889']
Sigma:
6.781969
c1:
[251.57582 306.49225 232.10927]
p1:
[209.21756 292.72357 200.85542]
c2:
[177.9324  289.0191  202.65912]
p2:
[203.39258 291.94672 204.24086]
My Reaction Template:
B(C1) + C(B1) <-> B(C1!1).C(B1!1)
Template Angles:
['1.994224', '2.557040', '-2.968996', '0.028420', '2.945889']
Template Sigma:
6.781969
Reaction:
C-2(G-2) + G-2(C-2) <-> C-2(G-2!1).G-2(C-2!1)
Angles:
['1.773549', '2.146643', '-1.243381', '-1.423627', '0.374929']
Sigma:
2.8267574
c1:
[167.82928 112.9126  232.10927]
p1:
[183.8562  122.20181 230.35022]
c2:
[182.51346 112.37132 225.19833]
p2:
[185.58835 120.17546 229.40994]
My Reaction Template:
B(D1) + D(B1, A1, A2) <-> B(D1!1).D(B1!1, A1, A2)
Template Angles:
['1.774031', '2.146613', '-1.242162', '-1.421457', '0.373421']
Template Sigma:
2.8271708
Reaction:
C-2(D-2) + D-2(C-2) <-> C-2(D-2!1).D-2(C-2!1)
Angles:
['1.994220', '2.557035', '-2.969002', '0.028433', '2.945883']
Sigma:
6.7819066
c1:
[167.82928 112.9126  232.10927]
p1:
[210.18753  126.681335 200.85542 ]
c2:
[241.47261 130.38583 202.65912]
p2:
[216.01244 127.45822 204.24086]
My Reaction Template:
B(C1) + C(B1) <-> B(C1!1).C(B1!1)
Template Angles:
['1.994224', '2.557040', '-2.968996', '0.028420', '2.945889']
Template Sigma:
6.781969
Reaction:
D(H) + H(D) <-> D(H!1).H(D!1)
Angles:
['0.629695', '1.477402', '-0.403433', 'nan', '-0.479292']
Sigma:
1.0779481
c1:
[177.9324  289.0191  202.65912]
p1:
[166.30919 305.45032 177.68285]
c2:
[165.79292 308.55106 186.39626]
p2:
[167.09087 304.77682 177.99487]
My Reaction Template:
C(E1) + E(C1) <-> C(E1!1).E(C1!1)
Template Angles:
['0.629695', '1.477402', '-0.403433', 'nan', '-0.479292']
Template Sigma:
1.0779481
Reaction:
D(G) + G(D) <-> D(G!1).G(D!1)
Angles:
['2.826745', '2.850471', '0.299006', '2.727712', '-0.910883']
Sigma:
7.725484
c1:
[177.9324  289.0191  202.65912]
p1:
[205.173   297.9995  221.75125]
c2:
[236.89151 307.03363 225.19797]
p2:
[211.96295 300.97998 223.9184 ]
My Reaction Template:
C(D1) + D(C1, A1, A2) <-> C(D1!1).D(C1!1, A1, A2)
Template Angles:
['2.826745', '2.850471', '0.299006', '2.727712', '-0.910883']
Template Sigma:
7.725484
Reaction:
D-2(H-2) + H-2(D-2) <-> D-2(H-2!1).H-2(D-2!1)
Angles:
['0.629687', '1.477397', '-0.403376', 'nan', '-0.479240']
Sigma:
1.0780017
c1:
[241.47261 130.38583 202.65912]
p1:
[253.09583 113.95465 177.68282]
c2:
[253.61208  110.854004 186.39626 ]
p2:
[252.31413  114.628204 177.99486 ]
My Reaction Template:
C(E1) + E(C1) <-> C(E1!1).E(C1!1)
Template Angles:
['0.629695', '1.477402', '-0.403433', 'nan', '-0.479292']
Template Sigma:
1.0779481
Reaction:
D-2(G-2) + G-2(D-2) <-> D-2(G-2!1).G-2(D-2!1)
Angles:
['2.826722', '2.851094', '0.297157', '2.725766', '-0.907695']
Sigma:
7.724506
c1:
[241.47261 130.38583 202.65912]
p1:
[214.23201  121.405426 221.75125 ]
c2:
[182.51346 112.37132 225.19833]
p2:
[207.44089 118.42906 223.91687]
My Reaction Template:
C(D1) + D(C1, A1, A2) <-> C(D1!1).D(C1!1, A1, A2)
Template Angles:
['2.826745', '2.850471', '0.299006', '2.727712', '-0.910883']
Template Sigma:
7.725484
After regularization:

5. Saving a Coarse-Grained Structure & PyMOL Script

You can export the coarse-grained data as a .cif file, plus a PyMOL script that displays spheres for COM and interface points.

[ ]:

model.save_regularized_coarse_grained_structure(
    output_cif='regularized_coarse_grained.cif',
    pymol_script='visualize_regularized_coarse.pml'
)
print('Coarse-grained structure saved, along with a PyMOL script!')
print('You can visualize the coarse-grained structure by running:')
print('pymol visualize_regularized_coarse.pml')

6. (Optional) Binding Energy with PyRosetta

If PyRosetta is installed, you can attempt a rough binding energy calculation for any chain pairs. This reports results in Rosetta Energy Units (REU).

[ ]:

model.calculate_binding_energies()

7. Generates the NERDSS Input files

[7]:

model.generate_nerdss_ready_files()

Generated .mol file: A.mol
Generated .mol file: B.mol
Generated .mol file: D.mol
Generated .mol file: C.mol
Generated .mol file: E.mol
Generated .inp file: parms.inp
All NERDSS-ready files generated successfully!