def get_connect_topology(self):
"""Dialog window for selecting new glycan. Can be either pdb or topology file
Intialize new_connect_top
"""
filename = tkFileDialog.askopenfilename(initialdir = self.cwd, title = "Select glycan library", filetypes = (("pdb files","*.pdb"), ("topology file", "*.top"), ("all files","*.*")))
if not filename:
return -1
path, file_extension = os.path.splitext(filename)
if file_extension == '.pdb':
glycan = glc.Molecule('glycan')
glycan.read_molecule_from_PDB(filename, update_bonds = False)
self.myGlycosylator.assign_patches(glycan)
connect_tree = self.myGlycosylator.build_connect_topology(glycan)
self.new_connect_top = self.connect_tree_to_topology(connect_tree)
elif file_extension == '.top':
name,self.new_connect_top = self.read_connect_topology(filename)
self.glycan_name_entry.insert(0, name)
root,tree,names = self.build_glycan_tree(self.new_connect_top['UNIT'])
self.new_glycan_image = self.draw_glycan_in_canvas(self.glycan_canvas, tree, root, names, h = 70., w = 70.)
self.structure_entry.configure(state='normal')
self.structure_entry.delete(0, tk.END)
self.structure_entry.insert(0, self.myDrawer.tree_to_text(tree, root, names, visited = []))
self.structure_entry.configure(state='disabled')
def glycosylate(self):
""" Glycosylate sequon with chosen glycan
"""
chid = self.chain.get()
sequon = self.sequon.get()
self.sequon_colors[sequon] = [.7, .1, 0]
key = self.sequon.get()
residue = self.myGlycosylator.get_residue(key)
#Build new glycan
if self.selected_glycan:
self.myGlycosylator.connect_topology[
'SELECTED'] = self.selected_glycan[1]
#build from current glycan
if key in self.original_glycans:
original_glycan = self.original_glycanMolecules[key].atom_group
r, t = self.original_glycans[key]
connect_tree = self.myGlycosylator.build_connectivity_tree(
r, t)
else:
original_glycan = None
connect_tree = None
#Use current glycan
else:
original_glycan = self.original_glycanMolecules[key]
r, t = self.original_glycans[key]
connect_tree = self.myGlycosylator.build_connectivity_tree(r, t)
self.myGlycosylator.connect_topology[
'SELECTED'] = self.myGlycosylator.build_connect_topology(
original_glycan)
original_glycan = original_glycan.atom_group
segname = 'G' + key.split(',')[2]
glycan, bonds = self.myGlycosylator.glycosylate(
'SELECTED',
template_glycan_tree=connect_tree,
template_glycan=original_glycan,
link_residue=residue,
link_patch='NGLB',
chain='G',
segname=segname)
new_glycan = glc.Molecule(key)
new_glycan.set_AtomGroup(glycan, bonds=bonds)
self.myGlycosylator.assign_patches(new_glycan)
self.linked_glycanMolecules[key] = new_glycan
self.linked_glycans[key] = [
new_glycan.rootRes, new_glycan.interresidue_connectivity
]
self.names.update(new_glycan.get_names())
# Update glycoprotein and sequon panels
self.draw_glycoprotein(chid)
self.draw_glycan(sequon)
import glycosylator as gl
import prody as pd
import os
################################################################################
# 1. Create a glycosylator
myGlycosylator = gl.Glycosylator(os.path.join(gl.GLYCOSYLATOR_PATH, 'support/toppar_charmm/carbohydrates.rtf'),
os.path.join(gl.GLYCOSYLATOR_PATH, 'support/toppar_charmm/carbohydrates.prm'))
# 2. Additional topology files (in this case for building glycans ab initio [DUMMY pathc])
myGlycosylator.builder.Topology.read_topology(os.path.join(gl.GLYCOSYLATOR_PATH, 'support/topology/DUMMY.top'))
# 3. Load glycan connectivity tree library
myGlycosylator.read_connectivity_topology(os.path.join(gl.GLYCOSYLATOR_PATH, 'support/topology/mannose.top'))
################################################################################
# 4. Identify glycan in mannose.top
myMan9 = gl.Molecule('mannose9')
myMan9.read_molecule_from_PDB(os.path.join(gl.GLYCOSYLATOR_PATH, 'support/examples/man9.pdb'), update_bonds=True)
myGlycosylator.assign_patches(myMan9)
print("Identified glycan: " + myGlycosylator.identify_glycan(myMan9))
################################################################################
# 5. Trim man9 down to man6
connect_tree = myGlycosylator.build_connectivity_tree(myMan9.rootRes, myMan9.interresidue_connectivity)
man6, bonds6 = myGlycosylator.glycosylate('MAN6_1;3,2', template_glycan_tree=connect_tree,
template_glycan=myMan9.atom_group)
myMan6 = gl.Molecule('mannose6')
myMan6.set_AtomGroup(man6, bonds=bonds6, update_bonds=False)
# Update angles and dihedrals based on bonds
myMan6.update_connectivity(update_bonds=False)
myGlycosylator.assign_patches(myMan6)
print("New glycan: " + myGlycosylator.identify_glycan(myMan6))
"""
import glycosylator as gl
import prody as pd
import os
################################################################################
# Creates a builder instance
# 1. Initialization requires a topology and parameter in CHARMM format
myBuilder = gl.MoleculeBuilder(
os.path.join(gl.GLYCOSYLATOR_PATH,
'support/toppar_charmm/carbohydrates.rtf'),
os.path.join(gl.GLYCOSYLATOR_PATH,
'support/toppar_charmm/carbohydrates.prm'))
myNAG = gl.Molecule('NAG')
myNAG.read_molecule_from_PDB(
os.path.join(gl.GLYCOSYLATOR_PATH, 'support/examples/NAG.pdb'))
NAG_complete, missing_atoms, bonds = myBuilder.add_missing_atoms(
myNAG.atom_group)
################################################################################
# 2. Add missing atoms
myBuilder.build_missing_atom_coord(NAG_complete, missing_atoms,
myBuilder.Topology.topology['NAG']['IC'])
# 3. Build in the missing atoms for internal coordinates
myNAG.set_AtomGroup(NAG_complete, bonds=bonds, update_bonds=False)
# Update angles and dihedrals based on bonds
myNAG.update_connectivity(update_bonds=False)
pd.writePDB('NAG_complete.pdb', NAG_complete)
################################################################################
# 4. Connect a second NAG using a 14bb connectivity
seg,chain,resid,i = sequon_id.split(',')
#skip unglycosylated sequons
if resid not in glycosylation:
continue
glycan_name = glycosylation[resid]
segname = chain + resid
#extend exiting glycans
if sequon_id in myGlycosylator.glycanMolecules:
template = myGlycosylator.glycanMolecules[sequon_id]
template_tree = myGlycosylator.build_connectivity_tree(template.rootRes, template.interresidue_connectivity)
glycan, bonds = myGlycosylator.glycosylate(glycan_name, template_glycan_tree = template_tree, template_glycan = template.atom_group, link_residue = sequon, link_patch = 'NGLB', chain = 'G', segname=segname)
#build glycan ab initio
else:
glycan, bonds = myGlycosylator.glycosylate(glycan_name, link_residue = sequon, link_patch = 'NGLB', chain = 'G', segname=segname)
new_glycan = gl.Molecule(sequon_id)
new_glycan.set_AtomGroup(glycan, bonds = bonds)
new_glycan.update_connectivity(update_bonds = False)
myGlycosylator.assign_patches(new_glycan)
at = myGlycosylator.assign_atom_type(new_glycan)
new_glycan.set_atom_type(at)
new_glycan.define_torsionals(hydrogens=False)
linked_glycanMolecules[sequon_id] = new_glycan
linked_glycans[sequon_id] = [new_glycan.rootRes, new_glycan.interresidue_connectivity]
################################################################################
# 5. Create a dictionary for storing new glycans
#Update glycan and save pdb
myGlycosylator.glycanMolecules.update(linked_glycanMolecules)
myGlycosylator.glycans.update(linked_glycans)
"""
import glycosylator as gl
import prody as pd
import os
################################################################################
# 1. Create a glycosylator
myGlycosylator = gl.Glycosylator(os.path.join(gl.GLYCOSYLATOR_PATH, 'support/toppar_charmm/carbohydrates.rtf'), os.path.join(gl.GLYCOSYLATOR_PATH, 'support/toppar_charmm/carbohydrates.prm'))
myGlycosylator.builder.Topology.read_topology(os.path.join(gl.GLYCOSYLATOR_PATH, 'support/topology/DUMMY.top'))
#Load topology information about glycans
myGlycosylator.read_connectivity_topology(os.path.join(gl.GLYCOSYLATOR_PATH, 'support/topology/mannose.top'))
################################################################################
# 2. Build a mannose 9 ab initio
man9, bonds = myGlycosylator.glycosylate('MAN9_3;4,2')
myMan9 = gl.Molecule('mannose9')
myMan9.set_AtomGroup(man9, bonds = bonds, update_bonds = False)
myMan9.update_connectivity(update_bonds = False)
myGlycosylator.assign_patches(myMan9)
################################################################################
# 3. Atom type and initialize from AtomGroup
atom_type = myGlycosylator.assign_atom_type(myMan9)
myMan9.set_atom_type(atom_type)
# 4. Do not consider torsional angles invovling terminal hydrogen
myMan9.define_torsionals(hydrogens = False)
################################################################################
# 5. Remove clashes with genetic algorithm
dihe_parameters = myGlycosylator.builder.Parameters.parameters['DIHEDRALS']
vwd_parameters = myGlycosylator.builder.Parameters.parameters['NONBONDED']
3. explicitly defining it (list of four the serial number of atoms)
The rotation angle is given in degrees and can be used to set
4. a new diherdal angle
5. to add an increment to the current angle.
6. A Molecule can also be initilized with an AtomGroup (from Prody)
"""
import glycosylator as gl
import prody as pd
import os
############################################################################
# Create a Molecule
myMan9 = gl.Molecule('mannose9')
# 1. Initialization with PDB file
# Load PDB file and guess all bonds, angles and dihedral angles
myMan9.read_molecule_from_PDB(os.path.join(gl.GLYCOSYLATOR_PATH,
'support/examples/man9.pdb'),
update_bonds=True)
# Define all torsionals angles
# Torsionals are defined by serial number of atoms
myMan9.define_torsionals()
print('#' * 50)
print('Number of torsional angles: %d', len(myMan9.torsionals))
print('#' * 50)
############################################################################
# Changing torsional angle
