Permalink
Cannot retrieve contributors at this time
Join GitHub today
GitHub is home to over 28 million developers working together to host and review code, manage projects, and build software together.
Sign up
Fetching contributors…
Cannot retrieve contributors at this time
| #!/usr/bin/python | |
| #//============================================================================== | |
| #// Artemis - Python molecular library for Brookhaven PDB files | |
| #// By Jamie Alnasir, 07/2014 | |
| #// Royal Holloway University of London | |
| #// CSSB - Centre for Systems and Synthetic Biology, dept. Computer Science | |
| #// Copyright (c) 2014 Jamie J. Alnasir, All Rights Reserved | |
| #//============================================================================== | |
| #// Version: Python edition | |
| #//============================================================================== | |
| import sys; | |
| import math; | |
| # The default example is to produce a report of the atoms in the PDB model by residue | |
| # and list the bonds computed/found within those residues. | |
| # Implementation to go in Implementation commented block towards the end of this | |
| # source code file. | |
| # Activities to perform (functional implementation provided): | |
| _PRINT_RESIDUES_ = True; # Print list of residue. | |
| _PRINT_RES_BONDS_ = True; # Print list of residue bonds (No effect if _PRINT_RESIDUES_=False). | |
| _PRINT_DIHEDRALS_ = True; # Print list of torsional/dihedral angles, by residue | |
| def main(): | |
| # Define our own Enum (Python 3.4 has it's own enum type) | |
| class Enum(object): | |
| def __init__(self, lstTuple): | |
| self.lstTuple = lstTuple | |
| def __getattr__(self, name): | |
| return self.lstTuple.index(name) | |
| # Enums for object attributes | |
| RESTYPE = Enum(('Unknown','AA', 'DNA')); | |
| HYBRIDISATION = Enum(('HYBRID_Unknown', 'HYBRID_SP1', 'HYBRID_SP2', 'HYBRID_SP3')); | |
| BOND_TYPE = Enum(('BOND_Ionic','BOND_Single','BOND_Double','BOND_Triple','BOND_HBond','BOND_VanDerWaals','BOND_Hydrogen','BOND_MeasureDist')); | |
| ATOM_SHELL_TYPE = Enum(('SHELL_S','SHELL_P','SHELL_D','SHELL_F')); | |
| # Consts | |
| KSTR_DNA_CODES = 'ATGCUI'; | |
| # Tuples (NB: Tuples are immutable) | |
| from collections import namedtuple | |
| tplPDBAtom = namedtuple('tplPDBAtom', "serial,name,alt_loc,chain_id,res_name,res_seq,icode,x,y,z,occ,temp,element,charge"); | |
| class TRealPoint: | |
| "3d vertex class" | |
| x=0; | |
| y=0; | |
| z=0; | |
| def __init__(self, a_x, a_y, a_z): | |
| self.x = a_x; | |
| self.y = a_y; | |
| self.z = a_z; | |
| def Distance3d(x1, y1, z1, x2, y2, z2): | |
| dx = (x2 - x1); | |
| dy = (y2 - y1); | |
| dz = (z2 - z1); | |
| tmp = dx * dx + dy * dy + dz * dz; | |
| return math.sqrt(tmp); | |
| def VectorSubtract(v1_x,v1_y,v1_z, v2_x,v2_y,v2_z): | |
| # Subtract V2 from V1 | |
| return [v1_x - v2_x, v1_y - v2_y, v1_z - v2_z]; | |
| def CrossProduct(v1_x, v1_y, v1_z, v2_x, v2_y, v2_z): | |
| return [v1_y * v2_z - v1_z * v2_y, v1_z * v2_x - v1_x * v2_z, v1_x * v2_y - v1_y * v2_x]; | |
| def DotProduct3d(v1_x, v1_y, v1_z, v2_x, v2_y, v2_z): | |
| # Return Dot product of two vectors | |
| return v1_x * v2_x + v1_y * v2_y + v1_z * v2_z; | |
| def CosAfromDotProduct(aDP, aLine1Len, aLine2Len): | |
| # Return CosA of Angle between lines aLine1 and aLine2 originating from 0 | |
| # of Lengths aLine1Len and aLine2Len respectively | |
| try: | |
| return aDP / (aLine1Len * aLine2Len); | |
| except ZeroDivisionError as errormsg: | |
| print 'An error occured: ', errormsg; | |
| return 0; | |
| def RadToDeg(Radians): | |
| return Radians * (180 / math.pi); | |
| def Angle(a0_x, a0_y, a0_z, a2_x, a2_y, a2_z, a3_x, a3_y, a3_z): | |
| # Three Atoms: a1 is Center atom (picked 1st), a2 and a3 are subsequently picked atoms | |
| # Lines are A and B which join at 0 | |
| # dx, dy, dz; # Difference in position (to get vector values) | |
| # lenA, lenB; # Lengths | |
| # DProd, CosA; | |
| lenA = Distance3d(a0_x, a0_y, a0_z, a2_x, a2_y, a2_z); | |
| lenB = Distance3d(a0_x, a0_y, a0_z, a3_x, a3_y, a3_z); | |
| dx = a2_x - a0_x; | |
| dy = a2_y - a0_y; | |
| dz = a2_z - a0_z; | |
| vA_x = dx; | |
| vA_y = dy; | |
| vA_z = dz; | |
| dx = a3_x - a0_x; | |
| dy = a3_y - a0_y; | |
| dz = a3_z - a0_z; | |
| vB_x = dx; | |
| vB_y = dy; | |
| vB_z = dz; | |
| DProd = DotProduct3d(vA_x, vA_y, vA_z, vB_x, vB_y, vB_z); | |
| CosA = CosAfromDotProduct(DProd, lenA, lenB); | |
| return RadToDeg(math.acos(CosA)); | |
| # --------------------------------------------------------------------------------------- | |
| # Jamie Al-Nasir, Notes for computing torsional angles: | |
| # In order to calculate torsional/dihedral angles within a peptide we need to inspect | |
| # the x,y,z cartessian coordinates for various main chain atoms in the amino acids of | |
| # the first two residues (n, n+1) for Phi and Psi angles and the second and third residues | |
| # (n+1, n+2) in the case of Ohmega. Then we iterate n accordingly and repeat the same | |
| # procedure for the other residues in the chain. NB The first Phi and last Psi angles | |
| # cannot be computed for the first and last residues in the chain. | |
| # --------------------------------------------------------------------------------------- | |
| def DihedralAngle(vA_x, vA_y, vA_z, vB_x, vB_y, vB_z, vC_x, vC_y, vC_z, vD_x, vD_y, vD_z): | |
| # | |
| # A | |
| # \ | |
| # B----C | |
| # \ | |
| # D | |
| arr_dist21 = VectorSubtract(vC_x, vC_y, vC_z, vB_x, vB_y, vB_z); | |
| arr_dist01 = VectorSubtract(vA_x, vA_y, vA_z, vB_x, vB_y, vB_z); | |
| arr_dist32 = VectorSubtract(vD_x, vD_y, vD_z, vC_x, vC_y, vC_z); | |
| dist21_x = arr_dist21[0]; dist21_y = arr_dist21[1]; dist21_z = arr_dist21[2]; | |
| dist01_x = arr_dist01[0]; dist01_y = arr_dist01[1]; dist01_z = arr_dist01[2]; | |
| dist32_x = arr_dist32[0]; dist32_y = arr_dist32[1]; dist32_z = arr_dist32[2]; | |
| arr_dd1 = CrossProduct(dist21_x, dist21_y, dist21_z, dist01_x, dist01_y, dist01_z); | |
| arr_dd3 = CrossProduct(dist21_x, dist21_y, dist21_z, dist32_x, dist32_y, dist32_z); | |
| dd1_x = arr_dd1[0]; dd1_y = arr_dd1[1]; dd1_z = arr_dd1[2]; | |
| dd3_x = arr_dd3[0]; dd3_y = arr_dd3[1]; dd3_z = arr_dd3[2]; | |
| r = Angle(0,0,0, dd1_x, dd1_y, dd1_z, dd3_x, dd3_y, dd3_z); | |
| arr_pos_d = CrossProduct(dist21_x, dist21_y, dist21_z, dd1_x, dd1_y, dd1_z); | |
| pos_d_x = arr_pos_d[0]; pos_d_y = arr_pos_d[1]; pos_d_z = arr_pos_d[2]; | |
| if (DotProduct3d(dd3_x, dd3_y, dd3_z, pos_d_x, pos_d_y, pos_d_z) < 0): | |
| r = -r; | |
| return r; | |
| def DihedralAngleHandler(vA, vB, vC, vD): | |
| # Handle extraction of coordinates from vector lists | |
| # for call ti DihedralAngle function | |
| vA_x = vA[0]; vA_y = vA[1]; vA_z = vA[2]; | |
| vB_x = vB[0]; vB_y = vB[1]; vB_z = vB[2]; | |
| vC_x = vC[0]; vC_y = vC[1]; vC_z = vC[2]; | |
| vD_x = vD[0]; vD_y = vD[1]; vD_z = vD[2]; | |
| return DihedralAngle(vA_x, vA_y, vA_z, vB_x, vB_y, vB_z, vC_x, vC_y, vC_z, vD_x, vD_y, vD_z); | |
| def ListTupleByAttrVal(aList, aAttrIndex, aVal): | |
| # Searches aList of Tuples for attribute (tuple attr index) for matching aVal | |
| tmp = [i for i in aList if i[aAttrIndex] == aVal]; | |
| if len(tmp) < 1: | |
| return None; | |
| else: | |
| return tmp[0]; | |
| def CoordsListFromAtomTuple(aTuple): | |
| if aTuple is not None: | |
| return [float(aTuple.x), float(aTuple.y), float(aTuple.z)]; | |
| else: | |
| return [0,0,0] | |
| def CreateAtomFromTuple(aAtomTuple): | |
| if not aAtomTuple is None: | |
| anAtom = TAtom(aAtomTuple); | |
| return anAtom; | |
| else: | |
| return None; | |
| def IsDNARes(aResName): | |
| if aResName[0] in KSTR_DNA_CODES: | |
| return True; | |
| else: | |
| return False; | |
| def GetPDBResType(aResName): | |
| r = RESTYPE.AA; | |
| tmpstr = aResName.strip(); | |
| if (len(tmpstr) == 1) and IsDNARes(tmpstr[0]): | |
| r = RESTYPE.DNA; | |
| else: | |
| if (len(tmpstr) == 2): | |
| if IsDNARes(tmpstr[1]): | |
| r = RESTYPE.DNA; # case of DA1, DG1 etc.. | |
| else: | |
| r = RESTYPE.AA; | |
| return r; | |
| if IsDNARes(aResName): | |
| return RESTYPE.DNA; | |
| else: | |
| return RESTYPE.AA; | |
| class TAtom: | |
| "Atom object class" | |
| __slots__ = ('bBackbone', 'bHydrogen', 'bComputed', 'Hybridisation', 'PDBData'); | |
| def __init__(self, PDBAtomTuple): | |
| self.xyz = TRealPoint(0,0,0); | |
| self.bBackBone = 0; | |
| self.bHydrogen = 0; | |
| self.bComputed = 0; | |
| self.Hybridisation = HYBRIDISATION.HYBRID_Unknown; | |
| self.PDBData = PDBAtomTuple; | |
| if PDBAtomTuple is not None: | |
| self.xyz.x = PDBAtomTuple.x; | |
| self.xyz.y = PDBAtomTuple.y; | |
| self.xyz.z = PDBAtomTuple.z; | |
| class TBond: | |
| "Bond object class" | |
| def __init__(self, a1=None, a2=None): | |
| self.Atom1 = a1; | |
| self.Atom2 = a2; | |
| if not self.Atom1 is None: | |
| self.Atom1.Hybridisation = HYBRIDISATION.HYBRID_Unknown; | |
| if not self.Atom2 is None: | |
| self.Atom1.Hybridisation = HYBRIDISATION.HYBRID_Unknown; | |
| self.SciAtomBondType = BOND_TYPE.BOND_Single; | |
| self.bBackBone = 0; | |
| self.bComputed = 0; | |
| def getBondName(self): | |
| r = ""; | |
| if self.Atom1 is None or self.Atom2 is None: | |
| return r; | |
| if self.Atom1.PDBData is None or self.Atom2.PDBData is None: | |
| return "Error: Atom.PDBData is null" + str(type(self.Atom1.PDBData)); | |
| r = self.Atom1.PDBData.name + " - " + self.Atom2.PDBData.name; | |
| return r; | |
| class TMolecule: | |
| "Molecule object base class" | |
| def __init__(self): | |
| self.lstBonds = []; | |
| def addBond(self, aBond): | |
| if not (aBond.Atom1 is None or aBond.Atom2 is None): | |
| if aBond not in self.lstBonds: | |
| self.lstBonds.append(aBond); | |
| class TResidue(TMolecule): | |
| "Residue object class" | |
| def __init__(self): | |
| TMolecule.__init__(self); | |
| self.res_name = ""; | |
| self.res_seq = ""; | |
| self.lstAtoms = []; | |
| self.chain_id = ""; | |
| self.res_type = RESTYPE.Unknown; | |
| def addAtomTuple(self, PDBAtomTuple): | |
| self.lstAtoms.append(PDBAtomTuple); | |
| def ComputeResBonds(self): | |
| # Adapted from the Zeus Molecular visualisation framework developed by Jamie Al-Nasir | |
| # Amino Acids =============================================================== | |
| # Check a-Amino backbone | |
| # Add bonds for a-Amino backbone, N-C-C=O | |
| # Covers GLY | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CA")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| # N-[C-C]=0 | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CA")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| # N-C-[C=0] | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O")); | |
| # C= is normally SP2 Hybridised | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP2; # C | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| # == ERROR a-backbone | |
| # Check a-Amino alkyl side-chain | |
| # Add bonds for alkyl side-chain, i.e. alpha-beta C, beta-gamma c, gamma-delta C | |
| # N-C-C=O | |
| #[|] | |
| #[C] | |
| # Caters for ALA, ILE | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CA")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| if (Bond.Atom1 is not None and Bond.Atom2 is not None): | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CA is SP3 | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CB is SP3 | |
| self.addBond(Bond); | |
| else: | |
| del Bond; | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| if (Bond.Atom1 is not None and Bond.Atom2 is not None): | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CA is SP3 | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CG is SP3 | |
| self.addBond(Bond); | |
| else: | |
| del Bond; | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD")); | |
| if (Bond.Atom1 is not None and Bond.Atom2 is not None): | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CG is SP3 | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CD is SP3 | |
| self.addBond(Bond); | |
| else: | |
| del Bond; | |
| # End Alkyl backbone | |
| if (self.res_name == "ASP"): | |
| # Add COO- to D-carbon of Alkyl side-chain | |
| # which one is the C=O double bond?? OD1 or OD2? use OD1 for now | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OD1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OD2")); | |
| self.addBond(Bond); | |
| if (self.res_name == "GLU"): | |
| # Add COO- to E-carbon of Alkyl side-chain | |
| # which one is the C=O double bond?? OD1 or OD2? use OD1 for now | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OE1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OE2")); | |
| self.addBond(Bond); | |
| if (self.res_name == "ILE"): | |
| # Add B-Carbon to 2x G-Carbon bonds and one G-Carbon-D-Carbon bond | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG1")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CB SP3 hybridised | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CG1 SP3 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG2")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CG2 SP3 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD1")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CD1 SP3 hybridised | |
| self.addBond(Bond); | |
| if (self.res_name == "LEU"): | |
| # Add 2x G-Carbon to D-Carbon bonds | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD1")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CD1 SP3 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CD2 SP3 hybridised | |
| self.addBond(Bond); | |
| if (self.res_name == "MET"): | |
| # Add G-Carbon to D-Sulphur and D-Sulphur to E-Carbon bonds | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "SD")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "SD")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # CE SP3 Hybridised | |
| self.addBond(Bond); | |
| if (self.res_name == "VAL"): | |
| # Add 2x B-Carbon to G-Carbon bonds | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG2")); | |
| self.addBond(Bond); | |
| if (self.res_name == "LYS"): | |
| # Add D-Carbon to E-Carbon bond and E-Carbon to Z-Nitrogen (NH3) bond | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP3; | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NZ")); | |
| self.addBond(Bond); | |
| if (self.res_name == "SER"): | |
| # Add B-Carbon to G-Oxygen (OH) bond | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OG")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # OG SP3 Hybridised (4 SP3 orbitals, 2 lone pairs, so bent) | |
| self.addBond(Bond); | |
| if (self.res_name == "THR"): | |
| # Add B-Carbon to G-Oxygen (OH) and B-Carbon to G-Carbon bonds | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OG1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG2")); | |
| self.addBond(Bond); | |
| if (self.res_name == "ASN"): | |
| # Add G-Carbon to D-Oxygen (C=O) bond | |
| # Add G-Carbon to D-Nitrogen (NH3) bond | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OD1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "ND2")); | |
| self.addBond(Bond); | |
| if (self.res_name == "GLN"): | |
| # Add D-Carbon to E-Oxygen (C=O) bond | |
| # Add D-Carbon to E-Nitrogen (NH3) bond | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OE1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NE2")); | |
| self.addBond(Bond); | |
| if (self.res_name == "ARG"): | |
| # Add D-Carbon to E-Nitrogen bond | |
| # Add E-Nitrogen to Z-Carbon bond | |
| # Add Z-Carbon double bond to H-N (NH2+) | |
| # Add Z-Carbon single bond to H-N (NH2) | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NE")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NE")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ")); | |
| self.addBond(Bond); | |
| # which one is the C=N double bond?? NH1 or NH2? use NH1 for now | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NH1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NH2")); | |
| self.addBond(Bond); | |
| if (self.res_name == "CYS"): | |
| # Add B-Carbon to G-Sulphur bond | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CB")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "SG")); | |
| self.addBond(Bond); | |
| if (self.res_name == "PRO"): | |
| # Add D-Carbon to Nitrogen bond which closes the ring in Proline | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N")); | |
| self.addBond(Bond); | |
| if (self.res_name == "PHE"): | |
| # Create Phenyl Ring from two parallel alkyl-chains which meet up at Z-Carbon | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE1")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP2; | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE2")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP2; | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP2; | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ")); | |
| self.addBond(Bond); | |
| if (self.res_name == "TYR"): | |
| # Create Phenyl Ring from two parallel alkyl-chains which meet up at Z-Carbon | |
| # Add bond to Z-Carbon to H-O (Phenolic-OH) | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD1")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CD1 SP2 hybridised | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CD1 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CD2 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE1")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CE1 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE2")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CE2 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "OH")); | |
| self.addBond(Bond); | |
| if (self.res_name == "HIS"): | |
| # Create Hetero Ring from two parallel alkyl-chains which meet up at Z-Carbon | |
| # Add bond to Z-Carbon to H-O (Phenolic-OH) | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CD2 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "ND1")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CD2 SP2 hybridised/protonated, + charge | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "ND1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE1")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CE1 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NE2")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NE2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE1")); | |
| self.addBond(Bond); | |
| if (self.res_name == "TRP"): | |
| # Create Phenyl Ring from two parallel alkyl-chains which meet up at Z-Carbon | |
| # Add bond to Z-Carbon to H-O (Phenolic-OH) | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD1")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CD1 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CG")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NE1")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "NE1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE2")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ2")); | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CH2")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CZ2 SP2 hybridised | |
| self.addBond(Bond); | |
| # | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CH2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ3")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CH2 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CZ3")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE3")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CZ3 SP2 hybridised | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP2; # CE3 SP2 hybridised | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CE3")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "CD2")); | |
| self.addBond(Bond); | |
| # Nucleic Acids ============================================================= | |
| if (self.res_name == "C"): | |
| # Cytosine | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N4")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| if (self.res_name == "T"): | |
| # Thymine | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O4")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| if (self.res_name == "A"): | |
| # Adenine | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N9")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C8")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C8")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N7")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N7")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N9")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| if (self.res_name == "G"): | |
| # Guanine | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N9")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C8")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C8")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N7")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N7")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N9")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| if (self.res_name == "I"): | |
| # Inosine | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N9")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C8")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C8")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N7")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N7")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O6")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C6")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N9")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N3")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # [N-C]-C=O | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N2")); | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| if (self.res_name == "C" or self.res_name == "G" or self.res_name == "I"): | |
| # Attach Purine to Sugar Phosphate | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N9")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C1*")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # C1* SP3 Hybridised | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| if (self.res_name == "C" or self.res_name == "t"): | |
| # Attach Pyramidine to Sugar Phosphate | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "N1")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C1*")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # C1* SP3 Hybridised | |
| Bond.bBackBone = False; | |
| self.addBond(Bond); | |
| # Phosphate Backbone | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O1P")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "P")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Double; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O2P")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "P")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C1*")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2*")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP3; # C1* SP3 Hybridised | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # C2* SP3 Hybridised | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C2*")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C3*")); | |
| if not Bond.Atom2 is None: | |
| Bond.Atom2.Hybridisation = HYBRIDISATION.HYBRID_SP3; # C1* SP3 Hybridised | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C3*")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4*")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4*")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O4*")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O4*")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C1*")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C4*")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5*")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C3*")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O3*")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "C5*")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O5*")); | |
| if not Bond.Atom1 is None: | |
| Bond.Atom1.Hybridisation = HYBRIDISATION.HYBRID_SP3; # C5* SP3 Hybridised | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| Bond = TBond(); | |
| Bond.BondType = BOND_TYPE.BOND_Single; | |
| Bond.Atom1 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "P")); | |
| Bond.Atom2 = CreateAtomFromTuple(ListTupleByAttrVal(self.lstAtoms, 1, "O5*")); | |
| Bond.bBackBone = 1; | |
| self.addBond(Bond); | |
| # Brookhaven PDB (Protein Databank file) format: | |
| # PDB file fixed-width columns | |
| #1 - 6 Record name "ATOM " | |
| #7 - 11 Integer serial Atom serial number. | |
| #13 - 16 Atom name Atom name. | |
| #17 Character altLoc Alternate location indicator. | |
| #18 - 20 Residue name resName Residue name. | |
| #22 Character chainID Chain identifier. | |
| #23 - 26 Integer resSeq Residue sequence number. | |
| #27 AChar iCode Code for insertion of residues. | |
| #31 - 38 Real(8.3) x Orthogonal coordinates for X in | |
| # Angstroms | |
| #39 - 46 Real(8.3) y Orthogonal coordinates for Y in | |
| # Angstroms | |
| #47 - 54 Real(8.3) z Orthogonal coordinates for Z in | |
| # Angstroms | |
| #55 - 60 Real(6.2) occupancy Occupancy. | |
| #61 - 66 Real(6.2) tempFactor Temperature factor. | |
| #77 - 78 LString(2) element Element symbol, right-justified. | |
| #79 - 80 LString(2) charge Charge on the atom. | |
| class TPDBModel: | |
| def __init__(self): | |
| self._data = []; | |
| self._pdb_file = ""; | |
| self.lstAtomTuples = []; # array to hold immutable atom tuples | |
| self.lstChains = []; # array to hold list of chain ids strings | |
| self.lstRes = []; # array to hold residue objects | |
| def _load(self): | |
| cur_res = ""; | |
| cur_chain = ""; | |
| aRes = TResidue(); | |
| for line in self._data: | |
| record_type = line[:6].strip(); | |
| atom_serial = line[7:11].strip(); | |
| atom_name = line[13:16].strip(); | |
| alt_loc = ""#line[17].strip(); | |
| res_name = line[17:20].strip(); | |
| chain_id = line[20:22].strip(); | |
| res_seq = line[23:26].strip(); | |
| icode = ""#line[27].strip(); | |
| x = line[31:38].strip(); | |
| y = line[39:46].strip(); | |
| z = line[47:54].strip(); | |
| occupancy = line[55:60].strip(); | |
| temp_factor = line[61:66].strip(); | |
| element = line[77:78].strip(); | |
| charge = line[79:80].strip(); | |
| #if (res_name <> res): | |
| if (record_type == "ATOM"): | |
| anAtomTuple = tplPDBAtom(atom_serial, atom_name, alt_loc, chain_id, res_name, res_seq, icode, x, y, z, occupancy, temp_factor, element, charge); | |
| #print record_type, atom_serial, chain_id, res_name, res_seq, x, y, z; | |
| self.lstAtomTuples.append(anAtomTuple); | |
| if (res_name + res_seq <> cur_res): | |
| if not aRes is None: | |
| self.lstRes.append(aRes); | |
| del aRes; | |
| aRes = TResidue(); | |
| aRes.res_name = res_name; | |
| aRes.res_seq = res_seq; | |
| cur_res = res_name + res_seq; | |
| aRes.res_type = GetPDBResType(res_name); | |
| #print id(aRes); | |
| aRes.addAtomTuple(anAtomTuple); | |
| aRes.chain_id = anAtomTuple.chain_id; | |
| #print anAtomTuple; | |
| if (chain_id <> cur_chain): | |
| if chain_id not in self.lstChains: | |
| self.lstChains.append(chain_id); | |
| cur_chain = chain_id; | |
| # last residue | |
| if not aRes is None: | |
| self.lstRes.append(aRes); | |
| def getResByChainID(self, chain_id): | |
| result = []; | |
| for aRes in PDBModel.lstRes: | |
| if (aRes.chain_id == chain_id): | |
| result.append(aRes); | |
| return result; | |
| def LoadFromFile(self, pdb_file): | |
| self._pdb_file = pdb_file; | |
| f = open(self._pdb_file, 'r'); | |
| self._data = f.readlines(); | |
| self._load(); | |
| def LoadFromStream(self): | |
| self._data = sys.stdin; | |
| self._load(); | |
| def RebuildPDB(self): | |
| print "Rebuilding PDB structure..."; | |
| self._data = []; | |
| serial = 0; | |
| # Copy non ATOM records/lines from before/after the block of ATOM record lines | |
| # so as to preserve user/program encoded data from the original PDB | |
| f = open(self._pdb_file, 'r'); | |
| _tmpdata = f.readlines(); | |
| lstHead = []; | |
| lstTail = []; | |
| bHead = True; | |
| for aHeaderLine in _tmpdata: | |
| if aHeaderLine.startswith('ATOM '): | |
| bHead = False; | |
| continue; | |
| else: | |
| if bHead: | |
| lstHead.append(aHeaderLine); | |
| else: | |
| lstTail.append(aHeaderLine); | |
| for aChain in PDBModel.lstChains: | |
| for aRes in PDBModel.getResByChainID(aChain): | |
| for anAtom in aRes.lstAtoms: | |
| serial = serial + 1; | |
| #print aChain + "\t" + anAtom.name + "\t" + anAtom.res_name + anAtom.res_seq + "\t" + anAtom.x + "\t" + anAtom.y + "\t" + anAtom.z + "\t"; | |
| pdb_line = '{:6s}{:>5s} {:4s}{:>3s} {:1s}{:>4s} {:>8s}{:>8s}{:>8s}'.format("ATOM",str(serial),anAtom.name,anAtom.res_name,anAtom.chain_id,anAtom.res_seq, anAtom.x, anAtom.y, anAtom.z); | |
| self._data.append(pdb_line); | |
| # Let _data now contain Header records + _data (Atom records) + Tail records | |
| self._data = lstHead + self._data + lstTail; | |
| def SaveToFile(self, pdb_file): | |
| self.RebuildPDB(); | |
| print "Saving " + pdb_file; | |
| f = open(pdb_file, 'w'); | |
| for line in self._data: | |
| f.write("%s\n" % line); | |
| #// Main ========================================================================== | |
| p = TRealPoint(1,2,3); | |
| b_stdin = not sys.stdin.isatty(); | |
| if ( (len(sys.argv) == 1 and (b_stdin == True)) or (len(sys.argv) == 2) ): | |
| if (len(sys.argv) == 1): | |
| PDBModel = TPDBModel(); | |
| PDBModel.LoadFromStream(); | |
| if (len(sys.argv) == 2): | |
| PDBModel = TPDBModel(); | |
| #PDBModel.load("./default.pdb"); | |
| PDBFile = sys.argv[1]; | |
| PDBModel.LoadFromFile(PDBFile); | |
| print "Artemis - Python molecular library for Brookhaven PDB files"; | |
| print "Copyright (c) 2014 Jamie J. Al-Nasir, All Rights Reserved"; | |
| print ""; | |
| if (len(sys.argv) == 2): | |
| print "Loaded: " + PDBFile; | |
| else: | |
| print "Loaded from <stdin> "; | |
| print ""; | |
| #// Implementation goes here ================================================== | |
| # PDBModel.lstChains contains a list of chain_id | |
| # PDBModel.getResByChainID returns a list of residues for given chain_id | |
| # PDBModel.lstRes contains a list of all residues | |
| # PDBModel.lstAtoms contains a list of all atom tuples (NB tuples are immutable) | |
| # aRes[n].lstBonds contains a list of all TBond *Objects* in the residue | |
| # a TBond contains two Atom *Objects* (not tuples) | |
| # | |
| # NB molecular geometry calculations can be used for a variety of computation tasks | |
| # such as calculating bond lengths and torsional/dihedral angles. | |
| # ----------------------------------------------------------------------------- | |
| # Saving Example: Create a new Residue and assign it to a new chain D then save | |
| #aNewRes = TResidue(); | |
| # Create the atoms for the new residue | |
| # aNewAtomTuple = "serial,name,alt_loc,chain_id,res_name,res_seq,icode, x, y, z, occ,temp,element,charge"); | |
| # NB: ATOM serial is auto generated during rebuild/save | |
| #aNewAtomTupleN = tplPDBAtom("auto", "N", "", "D", "TST", "155", "", "-1.001", "+2.002", "-3.003", "", "", "N", ""); | |
| #aNewAtomTupleCA = tplPDBAtom("auto", "CA", "", "D", "TST", "155", "", "-3.003", "+2.001", "-1.002", "", "", "CA", ""); | |
| #aNewAtomTupleC = tplPDBAtom("auto", "C", "", "D", "TST", "155", "", "-4.003", "+2.001", "-3.002", "", "", "C", ""); | |
| #aNewRes.addAtomTuple(aNewAtomTupleN); | |
| #aNewRes.addAtomTuple(aNewAtomTupleCA); | |
| #aNewRes.addAtomTuple(aNewAtomTupleC); | |
| #aNewRes.chain_id = "D"; | |
| #PDBModel.lstChains.append("D"); | |
| #PDBModel.lstRes.append(aNewRes); | |
| # If necessary call PDBModel.Rebuild (SaveToFile also performs rebuild prior to saving) | |
| # Save the modified PDB structure | |
| #PDBModel.SaveToFile('test_out.pdb'); | |
| #------------------------------------------------------------------------------ | |
| for aChain in PDBModel.lstChains: | |
| print "Chain: " + aChain; | |
| if _PRINT_RESIDUES_: | |
| for aRes in PDBModel.getResByChainID(aChain): | |
| print "\n"; | |
| print "Residue: " + aRes.res_name + aRes.res_seq; | |
| aRes.ComputeResBonds(); | |
| print "chain \t name \t residue x \t y \t z"; | |
| for anAtom in aRes.lstAtoms: | |
| print aChain + "\t" + anAtom.name + "\t" + anAtom.res_name + anAtom.res_seq + "\t" + anAtom.x + "\t" + anAtom.y + "\t" + anAtom.z + "\t"; | |
| if _PRINT_RES_BONDS_: | |
| print "\n"; | |
| print str(len(aRes.lstBonds)) + " Covalent bond(s) computed within this Residue:"; | |
| for aBond in aRes.lstBonds: | |
| print aBond.getBondName(); | |
| if _PRINT_DIHEDRALS_: | |
| print "\n"; | |
| print "Dihedral/Torsional angles for residues in chain " + aChain + ":"; | |
| aRes = PDBModel.getResByChainID(aChain); | |
| x = 1; | |
| while (x < len(aRes) - 1): | |
| x = x + 1; | |
| # We don't do DNA! | |
| if (aRes[x - 2].res_type == RESTYPE.DNA) or (aRes[x - 1].res_type == RESTYPE.DNA) or (aRes[x].res_type == RESTYPE.DNA): | |
| continue; | |
| #print aRes[x - 2].res_name + " " + aRes[x - 2].res_seq + str(CoordsListFromAtomTuple( ListTupleByAttrVal(aRes[x - 2].lstAtoms, 1, "C") )); | |
| res_atoms = aRes[x - 2].lstAtoms; | |
| tplN = ListTupleByAttrVal(res_atoms, 1, "N"); | |
| tplCA = ListTupleByAttrVal(res_atoms, 1, "CA"); | |
| tplC = ListTupleByAttrVal(res_atoms, 1, "C"); | |
| # We need a C from residue 1 | |
| if (tplC is None): | |
| continue; | |
| r1_N = CoordsListFromAtomTuple( tplN ); | |
| r1_CA = CoordsListFromAtomTuple( tplCA ); | |
| r1_C = CoordsListFromAtomTuple( tplC ); | |
| del res_atoms, tplN, tplCA, tplC; | |
| res_atoms = aRes[x - 1].lstAtoms; | |
| res_id = aRes[x - 1].res_name + aRes[x - 1].res_seq; # used for labelling | |
| tplN = ListTupleByAttrVal(res_atoms, 1, "N"); | |
| tplCA = ListTupleByAttrVal(res_atoms, 1, "CA"); | |
| tplC = ListTupleByAttrVal(res_atoms, 1, "C"); | |
| # We need N, CA, C from residue 2 | |
| if ((tplN is None) or (tplCA is None) or (tplC is None)): | |
| continue; | |
| r2_N = CoordsListFromAtomTuple( tplN ); | |
| r2_CA = CoordsListFromAtomTuple( tplCA ); | |
| r2_C = CoordsListFromAtomTuple( tplC ); | |
| del res_atoms, tplN, tplCA, tplC; | |
| res_atoms = aRes[x].lstAtoms; | |
| tplN = ListTupleByAttrVal(res_atoms, 1, "N"); | |
| tplCA = ListTupleByAttrVal(res_atoms, 1, "CA"); | |
| tplC = ListTupleByAttrVal(res_atoms, 1, "C"); | |
| # We need N, CA from residue 3 | |
| if ((tplN is None) or (tplCA is None)): | |
| continue; | |
| r3_N = CoordsListFromAtomTuple( tplN ); | |
| r3_CA = CoordsListFromAtomTuple( tplCA ); | |
| r3_C = CoordsListFromAtomTuple( tplC ); | |
| del res_atoms, tplN, tplCA, tplC; | |
| # Phi angle | |
| # x,y,z of First residue: C | |
| # x,y,z of Second residue: N | |
| # x,y,z of Second residue: Ca | |
| # x,y,z of Second residue: C | |
| # COMMENTED OUT UNTIL CAN EXPAND r1_N etc... to pass in x,y,z coordinates | |
| # AS DihedralAngle takes four sets of x,y,z coordinates | |
| Phi = DihedralAngleHandler(r1_C, r2_N, r2_CA, r2_C); | |
| # Psi | |
| # x,y,z of Second residue: N | |
| # x,y,z of Second residue: CA | |
| # x,y,z of Second residue: C | |
| # x,y,z of Third residue: N | |
| Psi = DihedralAngleHandler(r2_N, r2_CA, r2_C, r3_N); | |
| # Ohmega | |
| # x,y,z of Second residue: CA | |
| # x,y,z of Second residue: C | |
| # x,y,z of Third residue: N | |
| # x,y,z of Third residue: CA | |
| Ohmega = DihedralAngleHandler(r2_CA, r2_C, r3_N, r3_CA); | |
| #print "\t".join(["angles", res_id, str(Phi), str(Psi), str(Ohmega)]); | |
| print "Residue %s: Phi=%.3f, Psi=%.3f, Ohmega=%.3f" % (res_id, Phi, Psi, Ohmega); | |
| # Final spacer line | |
| print "\n"; | |
| #// EndImplementation ========================================================= | |
| else: | |
| print "Artemis - Python molecular library for Brookhaven PDB files"; | |
| print "Copyright (c) 2014 Jamie J. Al-Nasir, All Rights Reserved"; | |
| print ""; | |
| print "Build on the code, or provide a PDB file to process:"; | |
| print ""; | |
| print "Usage Artemis.py <file.pdb>"; | |
| print ""; | |
| # Main program execution in try-except block to catch un-caught exceptions | |
| # from elsewhere | |
| if __name__ == '__main__': | |
| try: | |
| main() | |
| except Exception as ErrMsg: | |
| print 'An error occured: ', ErrMsg; | |
| sys.exit(0); | |