Recycling Corner/Alpha Helix Generator
Revision as of 14:15, 23 October 2013 by AngelHerraez (talk | contribs)
RIBOZOME - an Alpha Helix Generator script
Creates an alpha helix from a user input string.
Jmol script by Ron Mignery with help from Angel Herráez
Contents
Script for Jmol application
# RIBOZOME - Jmol script by Ron Mignery with help from Angel Herráez
# v1.2 beta 10/23/2013
#
# New in v1.2 beta:
# No longer zaps existing atoms
# Now adds on to existing helix on subsequent runs
# Fixes proline cross-link bug with XXXXPXP
# Localizes variables and globalizes constants
#
# RIBOZOME takes a string message encoding an amino acid (aa) sequence
# and generates a corresponding alpha helix one aa at a time from the
# N terminus to the C terminus rotating the emerging helix as it goes.
#
# The message is a string entered by the user at a prompt.
# It may be typed in or pasted in and be of any length
# If the message is prepended with <C>: (where C is any single letter)
# then the chain is so labeled and separated from existing chains
# if different from the first chain.
#
# The IUPAC/IUBMB 1 letter code is used:
# A=ALAnine B=GLutam?X* C=CYSteine D=ASPartate E=GLUtamate
# F=PHEnylalanine G=GLYcine H=HIStidine I=IsoLEucine K=LYSine
# L=LEUcine M=METhionine N=ASparagiNe O=PYrroLysine*** P=PROline
# Q=GLutamiNe R=ARGinine S=SERine T=THReonine U=SElenoCysteine
# V=VALine W=TRyPtophan X=UNKnown Y=TYRosine Z=ASpar?X**
# *Either GLU or GLN: drawn as GLN with chi3 flipped
# **Either ASP or ASN: drawn as ASN with chi3 flipped
# ***Not supported: drawn as ALA
# The following constant values determine the pitch of the alpha helix
gPHI = -57 # Dihedral angle of N-CA bond (nominally -57)
gPSI = -47 # Dihedral angle of CA-C bond (nominally -47)
gOMEGA = 180 # Dihedral angle of the peptide bond (nominally 180)
gPEPTIDE_ANGLE = 110 # C-N-CA angle (nominally 110)
gPRO_BUMP = -10 # Psi angle change increment to N-3psi when N is Pro
gCHAIN = 'A' # The chain id
# Lookup 3 letter code from 1 letter code
g3from1 = {"A":"ALA", "B":"GLX","C":"CYS", "D":"ASP","E":"GLU", "F":"PHE",
"G":"GLY", "H":"HIS","I":"ILE", "K":"LYS","L":"LEU", "M":"MET",
"N":"GLN", "O":"PYL","P":"PRO", "Q":"GLN","R":"ARG", "S":"SER",
"T":"THR", "U":"SEC","V":"VAL", "W":"TRP","X":"UNK", "Y":"TYR", "Z":"ASX"}
# Generate PDB atom record
function genAtom(e, aa, i, xyz) {
gA = format("ATOM %5d %4s %3s ", gN, e, aa )
gA += format("%s%4d %8.3f", gCHAIN, i, xyz[1] )
gA += format("%8.3f%8.3f\n", xyz[2], xyz[3] )
gn++
return gA
};
# Generate a PDB amino acid record set
function genAA(i, aa) { # Writes globals gA and gN
# From constructed AAs
var N0 = [0.0, 0.0, 0.0]
var CA = [ 0.200, 1.174, 0.911 ]
var C = [ -1.110, 1.668, 1.425 ]
var O = [ -1.320, 1.693, 2.62 ]
var CB = [ 1.062, 2.1950, 0.230 ]
var G1 = [ 2.359, 1.607, -0.344]
var G2 = [ 1.363, 3.336, 1.157 ]
var D1 = [ 3.222, 2.656, -1.048 ]
var D2 = [ 3.143, 0.904, 0.725 ]
var E1 = [ 3.645, 3.749, -0.167 ]
var E2 = [ 2.491, 3.234, -2.249 ]
var Z = [ 4.470, 4.717, -0.885 ]
var H1 = [ 4.450, 6.006, -0.220 ]
var H2 = [5.833, 4.228, -0.984 ]
var Gp = [ 2.008, 1.24, -0.46 ]
var Dp = [1.022, 0.213, -1.031 ]
var Gfy = [ 2.368, 1.471, -0.0152 ]
var D1fy = [ 3.346, 1.524, 0.921 ]
var D2fy = [ 2.493, 0.516, -1.151 ]
var E1fy = [ 4.513, 0.615, 0.8244 ]
var E2fy = [ 3.528, -0.336, -1.206 ]
var Zfy = [ 4.588, -0.285, -0.168 ]
var Hfy = [ 5.738, -1.245, -0.233 ]
var Ghw = [ 2.406, 1.626, -0.134 ]
var D1hw = [3.498, 1.936, 0.675]
var D2hw = [ 2.713, 0.901, -1.211 ]
var E1hw = [ 4.160, 0.518, -1.178 ]
var E2hw = [ 4.622, 1.160, 0.0816 ]
var E3hw = [ 3.789, 2.523, 1.944 ]
var Z2hw = [ 5.973, 1.177, 0.689 ]
var Z3hw = [ 5.014, 2.550, 2.503 ]
var H2hw = [ 6.153, 1.846, 1.844 ]
#N1 = [ 2.069, -2.122, -0.554]
# Build PDB atom records common to all AAs
a3 = g3from1[aa]
if (a3 = "") {
a3 = "UNK"
}
print format("+ %s%d/%d", a3, i, gSeq.count + gResno)
gA = genAtom(" N ", a3, i, N0)
gA += genAtom(" CA ", a3, i, CA)
gA += genAtom(" C ", a3, i, C)
gA += genAtom(" O ", a3, i, O)
if ((aa != 'G') && (aa != 'X')) {
gA += genAtom(" CB ", a3, i, CB)
}
# Now add AA specific atom records
switch (aa) {
case 'A' :
break;
case 'B' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" CD ", a3, i, D1)
gA += genAtom(" OE1", a3, i, E2) # GLN with Es switched
gA += genAtom(" NE2", a3, i, E1)
break;
case 'C' :
gA += genAtom(" SG ", a3, i, G2)
break;
case 'D' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" OD1", a3, i, D1)
gA += genAtom(" OD2", a3, i, D2)
break;
case 'E' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" CD ", a3, i, D1)
gA += genAtom(" OE1", a3, i, E1)
gA += genAtom(" OE2", a3, i, E2)
break;
case 'F' :
gA += genAtom(" CG ", a3, i, Gfy)
gA += genAtom(" CD1", a3, i, D1fy)
gA += genAtom(" CD2", a3, i, D2fy)
gA += genAtom(" CE1", a3, i, E1fy)
gA += genAtom(" CE2", a3, i, E2fy)
gA += genAtom(" CZ ", a3, i, Zfy)
break;
case 'G' :
break;
case 'H' :
gA += genAtom(" CG ", a3, i, Ghw)
gA += genAtom(" ND1", a3, i, D1hw)
gA += genAtom(" CD2", a3, i, D2hw)
gA += genAtom(" CE1", a3, i, E2hw)
gA += genAtom(" NE2", a3, i, E1hw)
break;
case 'I' :
gA += genAtom(" CG1", a3, i, G1)
gA += genAtom(" CG2", a3, i, G2)
gA += genAtom(" CD1", a3, i, D1)
break;
case 'K' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" CD ", a3, i, D1)
gA += genAtom(" CE ", a3, i, E1)
gA += genAtom(" NZ ", a3, i, Z)
break;
case 'L' :
gA += genAtom(" CG1", a3, i, G1)
gA += genAtom(" CD1", a3, i, D1)
gA += genAtom(" CD2", a3, i, D2)
break;
case 'M' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" SD ", a3, i, D1)
gA += genAtom(" CE ", a3, i, E1)
break;
case 'N' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" OD1", a3, i, D1)
gA += genAtom(" ND2", a3, i, D2)
break;
case 'P' :
gA += genAtom(" CG ", a3, i, GP)
gA += genAtom(" CD ", a3, i, DP)
break;
case 'Q' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" CD ", a3, i, D1)
gA += genAtom(" OE1", a3, i, E1)
gA += genAtom(" NE2", a3, i, E2)
break;
case 'R' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" CD ", a3, i, D1)
gA += genAtom(" NE ", a3, i, E1)
gA += genAtom(" CZ ", a3, i, Z)
gA += genAtom(" NH1", a3, i, H1)
gA += genAtom(" NH2", a3, i, H2)
break;
case 'S' :
gA += genAtom(" OG ", a3, i, G1)
break;
case 'T' :
gA += genAtom(" OG1", a3, i, G1)
gA += genAtom(" CG2", a3, i, G2)
break;
case 'U' :
gA += genAtom("SeG ", a3, i, G1)
break;
case 'V' :
gA += genAtom(" CG1", a3, i, G1)
gA += genAtom(" CG2", a3, i, G2)
break;
case 'W' :
gA += genAtom(" CG ", a3, i, Ghw)
gA += genAtom(" CD1", a3, i, D1hw)
gA += genAtom(" CD2", a3, i, D2hw)
gA += genAtom(" CE2", a3, i, E2hw)
gA += genAtom(" NE1", a3, i, E1hw)
gA += genAtom(" CE3", a3, i, E3hw)
gA += genAtom(" CZ2", a3, i, Z2hw)
gA += genAtom(" CZ3", a3, i, Z3hw)
gA += genAtom(" CH2", a3, i, H2hw)
break;
case 'X' :
gA += genAtom(" Xx ", a3, i, CB)
break;
case 'Y' :
gA += genAtom(" CG ", a3, i, Gfy)
gA += genAtom(" CD1", a3, i, D1fy)
gA += genAtom(" CD2", a3, i, D2fy)
gA += genAtom(" CE1", a3, i, E1fy)
gA += genAtom(" CE2", a3, i, E2fy)
gA += genAtom(" CZ ", a3, i, Zfy)
gA += genAtom(" OH ", a3, i, Hfy)
break;
case 'Z' :
gA += genAtom(" CG ", a3, i, G1)
gA += genAtom(" OD1", a3, i, D2) # ASN with Ds switched
gA += genAtom(" ND2", a3, i, D1)
break;
default :
break;
}
return gA
};
# Generate an alpha helix
function genAlpha(gSeq) {
gN = all.count + 1 # global new N atom index
# Find last linkable N if any
gResno = 0 # global pre-existing AA count
var pn = 1 # previous gN
for (var i = all.count-1; i > 0; i--) {
# If found
if (distance({atomno=i}, {0,0,0}) < 0.1) {
pn = i
# If new chain, separate from existing chain
if ({atomno=i}.chain != gCHAIN) {
select all
translateselected {2.069, -2.122, -0.554 } #N1
}
else {
gResno = {atomno=i}.resno
}
break;
}
}
# For each aa
set appendnew false
var nn = gN # new N
for (var i = 1; i <= gSeq.count; i++) {
# Move polypeptide C to bond distance from new AA N
select all
fix none
translateselected {2.069, -2.122, -0.554 } #N1
# Gen AA
gA = "data \"append aa\"\n" # global PDB atom record
gA += genAA(i + gResno, gSeq[i]); # gN is updated in subroutine
gA += "end \"append aa\""
script inline @{gA}
# If PRO ahead
var pb = 0
if ((gSeq.count - i) >= 2) {
if (gSeq[i + 2] == 'P') {
pb = gPRO_BUMP
}
}
# If not first AA
if (nn > 1) {
# Gen axis on new N perpendicular to the plane
# containing atoms nn, pn+2 and nn+1
var v1={atomno = @{pn+2}}.xyz - {atomno = nn}.xyz
var v2={atomno = @{nn+1}}.xyz - {atomno = nn}.xyz
var axis = cross(v1, v2)
# Center on atom previous C
axis += {atomno = @{pn+2}}.xyz
# Rotate the polypeptide N on the new AA C to tetrahedral (nominally 110)
select atomno < nn
fix atomno >= nn
rotateselected @axis {atomno = nn} @{gPEPTIDE_ANGLE - 69.3}
# Make omega dihedral = gOMEGA (nominally 180)
rotateselected {atomno=@{pn+2}} {atomno=nn} @{gOMEGA - 147.4}
# Make the new phi dihedral = gPHI (nominally -57)
rotateselected {atomno = nn} {atomno = @{nn+1}} @{gPHI - 8.7}
# Make the old psi dihedral = gPSI (nominally -47)
select atomno < @{pn+2} && atomno != @{pn+3}
rotateselected {atomno=@{pn+1}} {atomno=@{pn+2}} @{gPSI + 33.4 + pb}
}
# Step new and previous N
pn = nn
nn = gN
# Make the peptide bond
connect
}
# Clean up
connect ([UNK].CA) ([UNK].Xx and within(group, _1))
select all
fix none
print format("%d atoms generated", gN)
}
echo Generating Alpha Helix
# Get the sequence from the user
gSeq = prompt("Enter AA sequence (1 char coded)", "")%9999%0
if (gSeq.count > 0) {
if (gSeq[2] == ':') {
gCHAIN = gSeq[1]
gSeq[1] = ' '
gSeq[2] = ' '
gSeq = gSeq%0
}
print format ("Sequence=%s phi=%d psi=%d", gSeq, gPHI, gPSI)
print format ("chain=%s peptide angle=%d pro bump=%d", gCHAIN, gPEPTIDE_ANGLE, gPRO_BUMP)
genAlpha(gSeq)
}
In a webpage
Using a J(S)mol object.
(coming soon...)
