Permalink
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); |