def ramachandran():
phi_angles = []
psi_angles = []
residues = list(struc.get_residues())
for i in range(1, len(residues) - 1):
res = residues[i]
res_prev = residues[i - 1]
res_next = residues[i + 1]
# Check residues have sequential residue numbers
if res.get_id()[1] == res_prev.get_id()[1] + 1 and res_next.get_id(
)[1] == res.get_id()[1] + 1:
try:
phi_angle = calc_dihedral(res_prev["C"].get_vector(),
res["N"].get_vector(),
res["CA"].get_vector(),
res["C"].get_vector())
psi_angle = calc_dihedral(res["N"].get_vector(),
res["CA"].get_vector(),
res["C"].get_vector(),
res_next["N"].get_vector())
phi_angles.append(phi_angle)
psi_angles.append(psi_angle)
except:
pass
return phi_angles, psi_angles
def test_same_dihedral(self):
"""The dihedral of the glycosidic bond before and after
substitution should be the same."""
# error in dihedral angle is 1.0 degrees.
# before (A)
a1 = self.adenosine["C2'"].get_vector()
a2 = self.adenosine["C1'"].get_vector()
a3 = self.adenosine["N9"].get_vector()
a4 = self.adenosine["C4"].get_vector()
a_dihedral = calc_dihedral(a1, a2, a3, a4)
# for G
exchange_base(self.adenosine, 'G')
g = self.adenosine
g1 = g["C2'"].get_vector()
g2 = g["C1'"].get_vector()
g3 = g["N9"].get_vector()
g4 = g["C4"].get_vector()
g_dihedral = calc_dihedral(g1, g2, g3, g4)
self.assertAlmostEqual(g_dihedral, a_dihedral, 2)
# for U
exchange_base(self.adenosine, 'U')
u = self.adenosine
u1 = u["C2'"].get_vector()
u2 = u["C1'"].get_vector()
u3 = u["N1"].get_vector()
u4 = u["C2"].get_vector()
u_dihedral = calc_dihedral(u1, u2, u3, u4)
self.assertAlmostEqual(u_dihedral, a_dihedral, 2)
def calculate_dihedrals(self):
"""
Calculates the dihedral angles:
"""
# create positive dihedrals [0..2pi]
posi = lambda x:x<0 and 2*pi+x or x
self.gamma = posi(calc_dihedral(self.vP5,self.vC5,self.vC3,self.vO3))
self.omega5 = posi(calc_dihedral(self.vO3,self.vC3,self.vC5,self.vN5))
self.omega3 = posi(calc_dihedral(self.vP5,self.vC5,self.vC3,self.vN3))
def get_phi_psi_list(self):
"""Return the list of phi/psi dihedral angles."""
ppl=[]
pplDict={}
lng=len(self)
for i in range(0, lng):
res=self[i]
try:
n=res['N'].get_vector()
ca=res['CA'].get_vector()
c=res['C'].get_vector()
except:
# Some atoms are missing
# Phi/Psi cannot be calculated for this residue
ppl.append((None, None))
pplDict.update({res:(None, None)})
res.xtra["PHI"]=None
res.xtra["PSI"]=None
continue
# Phi
if i>0:
rp=self[i-1]
try:
cp=rp['C'].get_vector()
phi=calc_dihedral(cp, n, ca, c)
except:
phi=None
else:
# No phi for residue 0!
phi=None
# Psi
if i<(lng-1):
rn=self[i+1]
try:
nn=rn['N'].get_vector()
psi=calc_dihedral(n, ca, c, nn)
except:
psi=None
else:
# No psi for last residue!
psi=None
ppl.append((phi, psi))
pplDict.update({res:(phi, psi)})
# Add Phi/Psi to xtra dict of residue
res.xtra["PHI"]=phi
res.xtra["PSI"]=psi
return pplDict
def _get_peptide_bond_conformation(res, prev_res):
""" Get the conformation of the peptide bond.
@param res: A residue
@type res: Residue
@param res: The previous residue
@type res: Residue
@rtype: int (cis: 0, trans: 1)
@return: Conformation of the peptide bond.
"""
CIS = 0
TRANS = 1
try:
CA_prev = prev_res['CA'].get_vector()
C_prev = prev_res['C'].get_vector()
N = res['N'].get_vector()
CA = res['CA'].get_vector()
dihedral = calc_dihedral(CA_prev, C_prev, N, CA)
except:
raise TorusDBNException("Could not obtain the conformation of the peptide bond.")
if abs(dihedral) < math.pi/4:
return CIS
else:
return TRANS
def get_torsion_angles(dir, atoms_list, plot):
p = PDBParser()
pdbs = glob.glob(dir + '/*', recursive=True)
points = []
for struct in pdbs:
print(struct)
structure = p.get_structure(struct.split('/')[1].split('.')[0], struct)
for chain in structure[0]: # model1
i = 0
coords = []
for residue in chain:
for atom in residue:
if atom.id == atoms_list[i]:
coords.append(atom.get_vector())
i = (i + 1) % 4
coords = coords[:int(len(coords) / 4) * 4]
coords = [coords[x:x + 100] for x in range(0, len(coords), 4)]
for four in coords:
points.append(
degrees(calc_dihedral(four[0], four[1], four[2], four[3])))
if plot:
plt.hist(points, alpha=0.5)
plt.xlabel('Torsion angles ' + atoms_list[0] + '-' + atoms_list[1] +
'-' + atoms_list[2] + '-' + atoms_list[3])
plt.show()
return points
def _dihedral(self, vec1, vec2, vec3, vec4):
"""Calculates torsion and makes sure it is between -180 and +180"""
torsion = calc_dihedral(vec1, vec2, vec3, vec4)
if torsion > 180:
return -(360 - torsion)
else:
return torsion
def omega(pp, i):
"""omega angle for peptide index i"""
ca=v_(pp, i, 'CA')
c=v_(pp, i, 'C')
nn=v_(pp, i+1, 'N')
can=v_(pp, i+1, 'CA')
return deg(calc_dihedral(ca, c, nn, can))
def psi(pp, i):
"""psi angle for peptide index i"""
n=v_(pp, i, 'N')
ca=v_(pp, i, 'CA')
c=v_(pp, i, 'C')
nn=v_(pp, i+1, 'N')
return deg(calc_dihedral(n, ca, c, nn))
def phi(pp, i):
"""phi angle for peptide index i"""
cp=v_(pp, i-1, 'C')
n=v_(pp, i, 'N')
ca=v_(pp, i, 'CA')
c=v_(pp, i, 'C')
return deg(calc_dihedral(cp, n, ca, c))
def calc_chi(self,r):
if r.long_abbrev in ['C','U']:
n1,n2 = ('N1','C2')
else:
n1,n2 = ('N9','C8')
chi = calc_dihedral(r["C2'"].get_vector(), r["C1'"].get_vector(),\
r[n1].get_vector(),r[n2].get_vector())
return chi * 180/math.pi
def ramachandran():
phi_angles = []
psi_angles = []
residues = list(struc.get_residues())
for i in range(1, len(residues) - 1):
res = residues[i]
res_prev = residues[i - 1]
res_next = residues[i + 1]
# Check residues have sequential residue numbers
if res.get_id()[1] == res_prev.get_id()[1] + 1 and res_next.get_id()[1] == res.get_id()[1] + 1:
try:
phi_angle = calc_dihedral(res_prev["C"].get_vector(), res["N"].get_vector(), res["CA"].get_vector(), res["C"].get_vector())
psi_angle = calc_dihedral(res["N"].get_vector(), res["CA"].get_vector(), res["C"].get_vector(), res_next["N"].get_vector())
phi_angles.append(phi_angle)
psi_angles.append(psi_angle)
except:
pass
return phi_angles, psi_angles
def get_phi_psi_list(self):
"""Return the list of phi/psi dihedral angles."""
ppl = []
lng = len(self)
for i in range(0, lng):
res = self[i]
try:
n = res['N'].get_vector()
ca = res['CA'].get_vector()
c = res['C'].get_vector()
except Exception:
# Some atoms are missing
# Phi/Psi cannot be calculated for this residue
ppl.append((None, None))
res.xtra["PHI"] = None
res.xtra["PSI"] = None
continue
# Phi
if i > 0:
rp = self[i - 1]
try:
cp = rp['C'].get_vector()
phi = calc_dihedral(cp, n, ca, c)
except Exception:
phi = None
else:
# No phi for residue 0!
phi = None
# Psi
if i < (lng - 1):
rn = self[i + 1]
try:
nn = rn['N'].get_vector()
psi = calc_dihedral(n, ca, c, nn)
except Exception:
psi = None
else:
# No psi for last residue!
psi = None
ppl.append((phi, psi))
# Add Phi/Psi to xtra dict of residue
res.xtra["PHI"] = phi
res.xtra["PSI"] = psi
return ppl
def calculateCoordinates(refA, refB, refC, L, ang, di):
AV=refA.get_vector()
BV=refB.get_vector()
CV=refC.get_vector()
CA=AV-CV
CB=BV-CV
##CA vector
AX=CA[0]
AY=CA[1]
AZ=CA[2]
##CB vector
BX=CB[0]
BY=CB[1]
BZ=CB[2]
##Plane Parameters
A=(AY*BZ)-(AZ*BY)
B=(AZ*BX)-(AX*BZ)
G=(AX*BY)-(AY*BX)
##Dot Product Constant
F= math.sqrt(BX*BX + BY*BY + BZ*BZ) * L * math.cos(ang*(math.pi/180.0))
##Constants
const=math.sqrt( math.pow((B*BZ-BY*G),2) *(-(F*F)*(A*A+B*B+G*G)+(B*B*(BX*BX+BZ*BZ) + A*A*(BY*BY+BZ*BZ)- (2*A*BX*BZ*G) + (BX*BX+ BY*BY)*G*G - (2*B*BY)*(A*BX+BZ*G))*L*L))
denom= (B*B)*(BX*BX+BZ*BZ)+ (A*A)*(BY*BY+BZ*BZ) - (2*A*BX*BZ*G) + (BX*BX+BY*BY)*(G*G) - (2*B*BY)*(A*BX+BZ*G)
X= ((B*B*BX*F)-(A*B*BY*F)+(F*G)*(-A*BZ+BX*G)+const)/denom
if((B==0 or BZ==0) and (BY==0 or G==0)):
const1=math.sqrt( G*G*(-A*A*X*X+(B*B+G*G)*(L-X)*(L+X)))
Y= ((-A*B*X)+const1)/(B*B+G*G)
Z= -(A*G*G*X+B*const1)/(G*(B*B+G*G))
else:
Y= ((A*A*BY*F)*(B*BZ-BY*G)+ G*( -F*math.pow(B*BZ-BY*G,2) + BX*const) - A*( B*B*BX*BZ*F- B*BX*BY*F*G + BZ*const)) / ((B*BZ-BY*G)*denom)
Z= ((A*A*BZ*F)*(B*BZ-BY*G) + (B*F)*math.pow(B*BZ-BY*G,2) + (A*BX*F*G)*(-B*BZ+BY*G) - B*BX*const + A*BY*const) / ((B*BZ-BY*G)*denom)
#GET THE NEW VECTOR from the orgin
D=Vector(X, Y, Z) + CV
with warnings.catch_warnings():
# ignore inconsequential warning
warnings.simplefilter("ignore")
temp=calc_dihedral(AV, BV, CV, D)*(180.0/math.pi)
di=di-temp
rot= rotaxis(math.pi*(di/180.0), CV-BV)
D=(D-BV).left_multiply(rot)+BV
return D.get_array()
def CalcDihedral(self,atom1,atom2,atom3,atom4):
if self.findResInStructure():
vector1=atom1.get_vector()
vector2=atom2.get_vector()
vector3=atom3.get_vector()
vector4=atom4.get_vector()
#print vector1, vector2,vector3,vector4
angle=calc_dihedral(vector1, vector2, vector3, vector4)*180/pi
#print angle
return angle
else:
return False
def get_tau_list(self):
"""List of tau torsions angles for all 4 consecutive Calpha atoms."""
ca_list = self.get_ca_list()
tau_list = []
for i in range(0, len(ca_list) - 3):
atom_list = (ca_list[i], ca_list[i + 1], ca_list[i + 2], ca_list[i + 3])
v1, v2, v3, v4 = [a.get_vector() for a in atom_list]
tau = calc_dihedral(v1, v2, v3, v4)
tau_list.append(tau)
# Put tau in xtra dict of residue
res = ca_list[i + 2].get_parent()
res.xtra["TAU"] = tau
return tau_list
def get_tau_list(self):
"""List of tau torsions angles for all 4 consecutive Calpha atoms."""
ca_list=self.get_ca_list()
tau_list=[]
for i in range(0, len(ca_list)-3):
atom_list = (ca_list[i], ca_list[i+1], ca_list[i+2], ca_list[i+3])
v1, v2, v3, v4 = [a.get_vector() for a in atom_list]
tau=calc_dihedral(v1, v2, v3, v4)
tau_list.append(tau)
# Put tau in xtra dict of residue
res=ca_list[i+2].get_parent()
res.xtra["TAU"]=tau
return tau_list
def _measure(self, vec1, vec2, vec3, vec4):
"""Returns a dist,angle,torsion tuple for the given four coords."""
dist = (vec3 - vec4).norm()
angle = math.degrees(calc_angle(vec2, vec3, vec4))
torsion = math.degrees(calc_dihedral(vec1, vec2, vec3, vec4))
return dist, angle, torsion
def calc_dihedral(self, atom1, atom2, atom3, atom4):
dihedral = calc_dihedral(atom1.get_vector(),\
atom2.get_vector(),atom3.get_vector(), atom4.get_vector())
dihedral *= 180 / math.pi
if dihedral < 0: dihedral += 360
return dihedral
def _measure(self, vec1, vec2, vec3, vec4):
"""Returns a dist,angle,torsion tuple for the given four coords."""
dist = (vec3 - vec4).norm()
angle = math.degrees(calc_angle(vec2, vec3, vec4))
torsion = math.degrees(calc_dihedral(vec1, vec2, vec3, vec4))
return dist, angle, torsion
