def correlation(x_items, y_items):
"""Returns Pearson correlation between x and y, and its significance."""
sum_x = sum_y = sum_x_sq = sum_y_sq = sum_xy = n = 0
for x, y in zip(x_items, y_items):
n += 1
sum_x += x
sum_x_sq += x * x
sum_y += y
sum_y_sq += y * y
sum_xy += x * y
try:
r = 1.0 * ((n * sum_xy) - (sum_x * sum_y)) / \
(sqrt((n * sum_x_sq)-(sum_x*sum_x))*sqrt((n*sum_y_sq)-(sum_y*sum_y)))
except (ZeroDivisionError, ValueError): #no variation
r = 0.0
#check we didn't get a naughty value for r due to rounding error
if r > 1.0:
r = 1.0
elif r < -1.0:
r = -1.0
if n < 3:
prob = 1
else:
try:
t = r/sqrt((1 - (r*r))/(n-2))
prob = tprob(t, n-2)
except ZeroDivisionError: #r was presumably 1
prob = 0
return (r, prob)
def writepov(self, file, dispdef):
if self.hidden: return
if self.is_disabled(): return #bruce 050421
c = self.posn()
a = self.axen()
xrot = -atan2(a[1], sqrt(1 - a[1] * a[1])) * 180 / pi
yrot = atan2(a[0], sqrt(1 - a[0] * a[0])) * 180 / pi
file.write("lmotor(" \
+ povpoint([self.width * 0.5, self.width * 0.5, self.length * 0.5]) + "," \
+ povpoint([self.width * -0.5, self.width * -0.5, self.length * -0.5]) + "," \
+ "<0.0, " + str(yrot) + ", 0.0>," \
+ "<" + str(xrot) + ", 0.0, 0.0>," \
+ povpoint(c) + "," \
+ "<" + str(self.color[0]) + "," + str(self.color[1]) + "," + str(self.color[2]) + ">)\n")
for a in self.atoms:
if vlen(
c - a.posn()
) > 0.001: #bruce 060808 add condition to see if this fixes bug 719 (two places in this file)
file.write("spoke(" + povpoint(c) + "," + povpoint(a.posn()) +
"," + str(self.sradius) + ",<" +
str(self.color[0]) + "," + str(self.color[1]) +
"," + str(self.color[2]) + ">)\n")
def txt_sqrt(norm, numeric=False):
if numeric:
return repr(sqrt(norm))
else:
if sqrt(norm) % 1 == 0:
return str(sqrt(norm))
else:
return "sqrt(" + str(norm.nom) + ("./" + str(norm.denom)) * (norm.denom != 1) + ")"
def txt_sqrt(norm, numeric=False):
if numeric:
return repr(sqrt(norm))
else:
if sqrt(norm) % 1 == 0:
return str(sqrt(norm))
else:
return 'sqrt(' + str(norm.nom) + \
('./' + str(norm.denom)) * (norm.denom != 1) + ')'
def txt_sqrt(norm, numeric=False):
if numeric:
return repr(sqrt(norm))
else:
if sqrt(norm) % 1 == 0:
return str(sqrt(norm))
else:
return 'sqrt(' + str(norm.nom) + \
('./' + str(norm.denom)) * (norm.denom != 1) + ')'
def test_euclidean_distance(self):
"""euclidean_distance: should return dist between 2 vectors or matrices
"""
a = array([3,4])
b = array([8,5])
c = array([[2,3],[4,5]])
d = array([[1,5],[8,2]])
self.assertFloatEqual(euclidean_distance(a,b),sqrt(26))
self.assertFloatEqual(euclidean_distance(c,d),sqrt(30))
def _getinfo_TEST(self): # please leave in for debugging POV-Ray lmotor macro. mark 060324
a = self.axen()
xrot = -atan2(a[1], sqrt(1-a[1]*a[1]))*180/pi
yrot = atan2(a[0], sqrt(1-a[0]*a[0]))*180/pi
return "[Object: Linear Motor] [Name: " + str(self.name) + "] " + \
"[Force = " + str(self.force) + " pN] " + \
"[Stiffness = " + str(self.stiffness) + " N/m] " + \
"[Axis = " + str(self.axis[0]) + ", " + str(self.axis[1]) + ", " + str(self.axis[2]) + "]" + \
"[xRotation = " + str(xrot) + ", yRotation = " + str(yrot) + "]"
def stats(data):
"""
Assumes a matrix of data with variables on the columns
and observations on the rows. Returns the mean,
variance and standard error of the data.
"""
from Numeric import average, sqrt
mean = average(data)
var = average((data - mean)**2)
stderr = sqrt(var) / sqrt(len(data))
return mean, var, stderr
def over_line(line):
# can't use the line bbox because it covers the entire extent
# of the line
xdata = line.transx.positions(line.get_xdata())
ydata = line.transy.positions(line.get_ydata())
distances = sqrt((x - xdata)**2 + (y - ydata)**2)
return min(distances) < epsilon
def init_cube():
drawing_globals.cubeVertices = cubeVertices = [[-1.0, 1.0, -1.0],
[-1.0, 1.0, 1.0],
[1.0, 1.0, 1.0],
[1.0, 1.0, -1.0],
[-1.0, -1.0, -1.0],
[-1.0, -1.0, 1.0],
[1.0, -1.0, 1.0],
[1.0, -1.0, -1.0]]
#bruce 051117: compute this rather than letting a subroutine hardcode it as
# a redundant constant
flatCubeVertices = []
for threemore in cubeVertices:
flatCubeVertices.extend(threemore)
flatCubeVertices = list(flatCubeVertices) #k probably not needed
drawing_globals.flatCubeVertices = flatCubeVertices
if 1: # remove this when it works
flatCubeVertices_hardcoded = [
-1.0, 1.0, -1.0, -1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, -1.0,
-1.0, -1.0, -1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0, 1.0, -1.0, -1.0
]
assert flatCubeVertices == flatCubeVertices_hardcoded
sq3 = sqrt(3.0) / 3.0
drawing_globals.cubeNormals = [[-sq3, sq3, -sq3], [-sq3, sq3, sq3],
[sq3, sq3, sq3], [sq3, sq3, -sq3],
[-sq3, -sq3, -sq3], [-sq3, -sq3, sq3],
[sq3, -sq3, sq3], [sq3, -sq3, -sq3]]
drawing_globals.cubeIndices = [[0, 1, 2, 3], [0, 4, 5, 1], [1, 5, 6, 2],
[2, 6, 7, 3], [0, 3, 7, 4], [4, 7, 6, 5]]
return
def corrcoef(*args):
"""
corrcoef(X) where X is a matrix returns a matrix of correlation
coefficients for each row of X.
corrcoef(x,y) where x and y are vectors returns the matrix or
correlation coefficients for x and y.
Numeric arrays can be real or complex
The correlation matrix is defined from the covariance matrix C as
r(i,j) = C[i,j] / (C[i,i]*C[j,j])
"""
if len(args) == 2:
X = transpose(array([args[0]] + [args[1]]))
elif len(args == 1):
X = args[0]
else:
raise RuntimeError, 'Only expecting 1 or 2 arguments'
C = cov(X)
d = resize(diagonal(C), (2, 1))
r = divide(C, sqrt(matrixmultiply(d, transpose(d))))[0, 1]
try:
return r.real
except AttributeError:
return r
def Length(self): """Length of vector Returns the length of the vector generated by the basis. """ from Numeric import sqrt return sqrt(self.InnerProduct(self))
def test_vanishing_moments(self):
"""Test that coefficients in lp satisfy the
vanishing moments condition
"""
from daubfilt import daubfilt, number_of_filters
for i in range(number_of_filters):
D = 2*(i+1)
P = D/2 # Number of vanishing moments
N = P-1 # Dimension of nullspace of the matrix A
R = P+1 # Rank of A, R = D-N = P+1 equations
lp, hp = daubfilt(D)
# Condition number of A grows with P, so we test only
# the first 6 (and eps is slightly larger than machine precision)
A = zeros((R,D), Float) # D unknowns, D-N equations
b = zeros((R,1), Float) # Right hand side
b[0] = sqrt(2)
A[0,:] = ones(D, Float) # Coefficients must sum to sqrt(2)
for p in range(min(P,6)): # the p'th vanishing moment (Cond Ap)
for k in range(D):
m=D-k;
A[p+1,k] = (-1)**m * k**p;
assert allclose(b, mvmul(A,lp))
def test_randomSequence(self):
"""randomSequence: 99% of new frequencies should be within 3*SD"""
r_num, c_num = 100,20
num_elements = r_num*c_num
alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
r = random([r_num,c_num])
p = Profile(r,alpha[:c_num])
p.normalizePositions()
d = p.Data
n = 1000
#Test only works on normalized profile, b/c of 1-d below
means = n*d
three_stds = sqrt(d*(1-d)*n)*3
a = Alignment([p.randomSequence() for x in range(n)])
def absoluteProfile(alignment,char_order):
f = a.columnFrequencies()
res = zeros([len(f),len(char_order)])
for row, freq in enumerate(f):
for i in freq:
col = char_order.index(i)
res[row, col] = freq[i]
return res
ap = absoluteProfile(a,p.CharOrder)
failure = abs(ap-means) > three_stds
assert sum(sum(failure))/num_elements <= 0.01
def over_line(line):
# can't use the line bbox because it covers the entire extent
# of the line
xdata = line.transx.positions(line.get_xdata())
ydata = line.transy.positions(line.get_ydata())
distances = sqrt((x - xdata) ** 2 + (y - ydata) ** 2)
return min(distances) < epsilon
def test_euclidean_distance_unexpected(self):
"""euclidean_distance: works always when frames are aligned. UNEXPECTED!
"""
a = array([3,4])
b = array([8,5])
c = array([[2,3],[4,5]])
d = array([[1,5],[8,2]])
e = array([[4,5],[4,5],[4,5]])
f = array([1,1,1,1,1])
self.assertFloatEqual(euclidean_distance(a,c),sqrt(4))
self.assertFloatEqual(euclidean_distance(c,a),sqrt(4))
self.assertFloatEqual(euclidean_distance(a,e),sqrt(6))
#IT DOES RAISE AN ERROR WHEN THE FRAMES ARE NOT ALIGNED
self.assertRaises(ValueError,euclidean_distance,c,e)
self.assertRaises(ValueError,euclidean_distance,c,f)
def Length(self):
"""Length of vector
Returns the length of the vector generated by the basis.
"""
from Numeric import sqrt
return sqrt(self.InnerProduct(self))
def init_diamond():
# a chunk of diamond grid, to be tiled out in 3d
drawing_globals.sp0 = sp0 = 0.0
#bruce 051102 replaced 1.52 with this constant (1.544),
# re bug 900 (partial fix.)
drawing_globals.sp1 = sp1 = DIAMOND_BOND_LENGTH / sqrt(3.0)
sp2 = 2.0*sp1
sp3 = 3.0*sp1
drawing_globals.sp4 = sp4 = 4.0*sp1
digrid=[[[sp0, sp0, sp0], [sp1, sp1, sp1]],
[[sp1, sp1, sp1], [sp2, sp2, sp0]],
[[sp2, sp2, sp0], [sp3, sp3, sp1]],
[[sp3, sp3, sp1], [sp4, sp4, sp0]],
[[sp2, sp0, sp2], [sp3, sp1, sp3]],
[[sp3, sp1, sp3], [sp4, sp2, sp2]],
[[sp2, sp0, sp2], [sp1, sp1, sp1]],
[[sp1, sp1, sp1], [sp0, sp2, sp2]],
[[sp0, sp2, sp2], [sp1, sp3, sp3]],
[[sp1, sp3, sp3], [sp2, sp4, sp2]],
[[sp2, sp4, sp2], [sp3, sp3, sp1]],
[[sp3, sp3, sp1], [sp4, sp2, sp2]],
[[sp4, sp0, sp4], [sp3, sp1, sp3]],
[[sp3, sp1, sp3], [sp2, sp2, sp4]],
[[sp2, sp2, sp4], [sp1, sp3, sp3]],
[[sp1, sp3, sp3], [sp0, sp4, sp4]]]
drawing_globals.digrid = A(digrid)
drawing_globals.DiGridSp = sp4
return
def findHandles_exact(self, p1, p2, cutoff = 0.0, backs_ok = 1, offset = V(0,0,0)):
"""
return a list of (dist, handle) pairs, in arbitrary order,
which includes, for each handle (spherical surface) hit by the ray from p1 thru p2,
its front-surface intersection with the ray,
unless that has dist < cutoff and backs_ok,
in which case include its back-surface intersection
(unless *that* has dist < cutoff).
"""
#e For now, just be simple, don't worry about speed.
# Someday we can preprocess self.handlpos using Numeric functions,
# like in nearSinglets and/or findSinglets
# (I have untested prototype code for this in extrude-outs.py).
hh = self.handles
res = []
v = norm(p2-p1)
## is this modifying the vector in-place, causing a bug?? offset += self.origin # treat our handles' pos as relative to this
## I don't know, but one of the three instances of += was doing this!!! probably i was resetting the atom or mol pos....
offset = offset + self.origin # treat our handles' pos as relative to this
radius_multiplier = self.radius_multiplier
for (pos,radius,info) in hh:
## bug in this? pos += offset
pos = pos + offset
radius *= radius_multiplier
dist, wid = orthodist(p1, v, pos)
if radius >= wid: # the ray hits the sphere
delta = sqrt(radius*radius - wid*wid)
front = dist - delta # depth from p1 of front surface of sphere, where it's hit
if front >= cutoff:
res.append((front,(pos,radius,info)))
elif backs_ok:
back = dist + delta
if back >= cutoff:
res.append((back,(pos,radius,info)))
return res
def t_two_sample (a, b, tails=None, exp_diff=0):
"""Returns t, prob for two INDEPENDENT samples of scores a, and b.
From Sokal and Rohlf, p 223.
Usage: t, prob = t_two_sample(a,b, tails, exp_diff)
t is a float; prob is a probability.
a and b should be lists of observations (numbers) supporting Mean, Count,
and Variance. Need not be equal.
tails should be None (default), 'high', or 'low'.
exp_diff should be the expected difference in means (a-b); 0 by default.
"""
try:
#see if we need to back off to the single-observation for single-item
#groups
n1 = a.Count
if n1 < 2:
return t_one_observation(a.Sum, b, tails, exp_diff)
n2 = b.Count
if n2 < 2:
return t_one_observation(b.Sum, a, reverse_tails(tails), exp_diff)
#otherwise, calculate things properly
x1 = a.Mean
x2 = b.Mean
df = n1+n2-2
svar = ((n1-1)*a.Variance + (n2-1)*b.Variance)/df
t = (x1-x2-exp_diff)/sqrt(svar*(1/n1 + 1/n2))
except (ZeroDivisionError, ValueError, AttributeError, TypeError):
#bail out if the sample sizes are wrong, the values aren't numeric or
#aren't present, etc.
return (None, None)
prob = t_tailed_prob(t, df, tails)
return t, prob
def init_diamond():
# a chunk of diamond grid, to be tiled out in 3d
drawing_globals.sp0 = sp0 = 0.0
#bruce 051102 replaced 1.52 with this constant (1.544),
# re bug 900 (partial fix.)
drawing_globals.sp1 = sp1 = DIAMOND_BOND_LENGTH / sqrt(3.0)
sp2 = 2.0 * sp1
sp3 = 3.0 * sp1
drawing_globals.sp4 = sp4 = 4.0 * sp1
digrid = [[[sp0, sp0, sp0], [sp1, sp1, sp1]],
[[sp1, sp1, sp1], [sp2, sp2, sp0]],
[[sp2, sp2, sp0], [sp3, sp3, sp1]],
[[sp3, sp3, sp1], [sp4, sp4, sp0]],
[[sp2, sp0, sp2], [sp3, sp1, sp3]],
[[sp3, sp1, sp3], [sp4, sp2, sp2]],
[[sp2, sp0, sp2], [sp1, sp1, sp1]],
[[sp1, sp1, sp1], [sp0, sp2, sp2]],
[[sp0, sp2, sp2], [sp1, sp3, sp3]],
[[sp1, sp3, sp3], [sp2, sp4, sp2]],
[[sp2, sp4, sp2], [sp3, sp3, sp1]],
[[sp3, sp3, sp1], [sp4, sp2, sp2]],
[[sp4, sp0, sp4], [sp3, sp1, sp3]],
[[sp3, sp1, sp3], [sp2, sp2, sp4]],
[[sp2, sp2, sp4], [sp1, sp3, sp3]],
[[sp1, sp3, sp3], [sp0, sp4, sp4]]]
drawing_globals.digrid = A(digrid)
drawing_globals.DiGridSp = sp4
return
def min_dist(coord, surface):
"""
Return minimum distance between coord
and surface.
"""
d=surface-coord
d2=sum(d*d, 1)
return sqrt(min(d2))
def __str__(self):
n = self.norm
sn = sqrt(n)
if int(sn) == sn:
string = repr(sn) + "/sqrt(pi)"
else:
string = "sqrt(" + repr(n.nom) + ("./" + repr(n.denom)) * (n.denom != 1) + "/pi)"
return string
def __str__(self):
n = self.norm
sn = sqrt(n)
if int(sn) == sn:
string = repr(sn) + '/sqrt(pi)'
else:
string = 'sqrt(' + repr(n.nom) + \
('./' + repr(n.denom)) * (n.denom != 1) + '/pi)'
return string
def computeEndPointsFromChunk(self, chunk, update = True):
"""
Derives and returns the endpoints and radius of a Peptide chunk.
@param chunk: a Peptide chunk
@type chunk: Chunk
@return: endPoint1, endPoint2 and radius
@rtype: Point, Point and float
@note: computing the endpoints works fine when n=m or m=0. Otherwise,
the endpoints can be slightly off the central axis, especially
if the Peptide is short.
@attention: endPoint1 and endPoint2 may not be the original endpoints,
and they may be flipped (opposites of) the original
endpoints.
"""
# Since chunk.axis is not always one of the vectors chunk.evecs
# (actually chunk.poly_evals_evecs_axis[2]), it's best to just use
# the axis and center, then recompute a bounding cylinder.
if not chunk.atoms:
return None
axis = chunk.axis
axis = norm(axis) # needed
center = chunk._get_center()
points = chunk.atpos - center # not sure if basepos points are already centered
# compare following Numeric Python code to findAtomUnderMouse and its caller
matrix = matrix_putting_axis_at_z(axis)
v = dot( points, matrix)
# compute xy distances-squared between axis line and atom centers
r_xy_2 = v[:,0]**2 + v[:,1]**2
# to get radius, take maximum -- not sure if max(r_xy_2) would use Numeric code, but this will for sure:
i = argmax(r_xy_2)
max_xy_2 = r_xy_2[i]
radius = sqrt(max_xy_2)
# to get limits along axis (since we won't assume center is centered between them), use min/max z:
z = v[:,2]
min_z = z[argmin(z)]
max_z = z[argmax(z)]
# Adjust the endpoints such that the ladder rungs (rings) will fall
# on the ring segments.
# TO DO: Fix drawPeptideLadder() to offset the first ring, then I can
# remove this adjustment. --Mark 2008-04-12
z_adjust = self.getEndPointZOffset()
min_z += z_adjust
max_z -= z_adjust
endpoint1 = center + min_z * axis
endpoint2 = center + max_z * axis
if update:
#print "Original endpoints:", self.getEndPoints()
self.setEndPoints(endpoint1, endpoint2)
#print "New endpoints:", self.getEndPoints()
return (endpoint1, endpoint2, radius)
def __str__(self):
n = self.norm
sn = sqrt(n)
if int(sn) == sn:
string = repr(sn) + '/sqrt(pi)'
else:
string = 'sqrt(' + repr(n.nom) + \
('./' + repr(n.denom)) * (n.denom != 1) + '/pi)'
return string
def computeEndPointsFromChunk(self, chunk, update=True):
"""
Derives and returns the endpoints and radius of a Peptide chunk.
@param chunk: a Peptide chunk
@type chunk: Chunk
@return: endPoint1, endPoint2 and radius
@rtype: Point, Point and float
@note: computing the endpoints works fine when n=m or m=0. Otherwise,
the endpoints can be slightly off the central axis, especially
if the Peptide is short.
@attention: endPoint1 and endPoint2 may not be the original endpoints,
and they may be flipped (opposites of) the original
endpoints.
"""
# Since chunk.axis is not always one of the vectors chunk.evecs
# (actually chunk.poly_evals_evecs_axis[2]), it's best to just use
# the axis and center, then recompute a bounding cylinder.
if not chunk.atoms:
return None
axis = chunk.axis
axis = norm(axis) # needed
center = chunk._get_center()
points = chunk.atpos - center # not sure if basepos points are already centered
# compare following Numeric Python code to findAtomUnderMouse and its caller
matrix = matrix_putting_axis_at_z(axis)
v = dot(points, matrix)
# compute xy distances-squared between axis line and atom centers
r_xy_2 = v[:, 0] ** 2 + v[:, 1] ** 2
# to get radius, take maximum -- not sure if max(r_xy_2) would use Numeric code, but this will for sure:
i = argmax(r_xy_2)
max_xy_2 = r_xy_2[i]
radius = sqrt(max_xy_2)
# to get limits along axis (since we won't assume center is centered between them), use min/max z:
z = v[:, 2]
min_z = z[argmin(z)]
max_z = z[argmax(z)]
# Adjust the endpoints such that the ladder rungs (rings) will fall
# on the ring segments.
# TO DO: Fix drawPeptideLadder() to offset the first ring, then I can
# remove this adjustment. --Mark 2008-04-12
z_adjust = self.getEndPointZOffset()
min_z += z_adjust
max_z -= z_adjust
endpoint1 = center + min_z * axis
endpoint2 = center + max_z * axis
if update:
# print "Original endpoints:", self.getEndPoints()
self.setEndPoints(endpoint1, endpoint2)
# print "New endpoints:", self.getEndPoints()
return (endpoint1, endpoint2, radius)
def norm(a):
"""Returns the norm of a matrix or vector
Calculates the Euclidean norm of a vector.
Applies the Frobenius norm function to a matrix
(a.k.a. Euclidian matrix norm)
a = Numeric array
"""
return sqrt(sum((a*a).flat))
def compute_memo(self, chunk):
"""
If drawing chunk in this display mode can be optimized by precomputing some info from chunk's appearance,
compute that info and return it.
If this computation requires preference values, access them as env.prefs[key],
and that will cause the memo to be removed (invalidated) when that preference value is changed by the user.
This computation is assumed to also depend on, and only on, chunk's appearance in ordinary display modes
(i.e. it's invalidated whenever havelist is). There is not yet any way to change that,
so bugs will occur if any ordinarily invisible chunk info affects this rendering,
and potential optimizations will not be done if any ordinarily visible info is not visible in this rendering.
These can be fixed if necessary by having the real work done within class Chunk's _recompute_ rules,
with this function or drawchunk just accessing the result of that (and sometimes causing its recomputation),
and with whatever invalidation is needed being added to appropriate setter methods of class Chunk.
If the real work can depend on more than chunk's ordinary appearance can, the access would need to be in drawchunk;
otherwise it could be in drawchunk or in this method compute_memo.
"""
# for this example, we'll turn the chunk axes into a cylinder.
# Since chunk.axis is not always one of the vectors chunk.evecs (actually chunk.poly_evals_evecs_axis[2]),
# it's best to just use the axis and center, then recompute a bounding cylinder.
if not chunk.atoms:
return None
axis = chunk.axis
axis = norm(
axis
) # needed (unless we're sure it's already unit length, which is likely)
center = chunk.center
points = chunk.atpos - center # not sure if basepos points are already centered
# compare following Numeric Python code to findAtomUnderMouse and its caller
matrix = matrix_putting_axis_at_z(axis)
v = dot(points, matrix)
# compute xy distances-squared between axis line and atom centers
r_xy_2 = v[:, 0]**2 + v[:, 1]**2
## r_xy = sqrt(r_xy_2) # not needed
# to get radius, take maximum -- not sure if max(r_xy_2) would use Numeric code, but this will for sure:
i = argmax(r_xy_2)
max_xy_2 = r_xy_2[i]
radius = sqrt(max_xy_2)
# to get limits along axis (since we won't assume center is centered between them), use min/max z:
z = v[:, 2]
min_z = z[argmin(z)]
max_z = z[argmax(z)]
bcenter = chunk.abs_to_base(center)
# return, in chunk-relative coords, end1, end2, and radius of the cylinder, and color.
color = chunk.color
if color is None:
color = V(0.5, 0.5, 0.5)
# make sure it's longer than zero (in case of a single-atom chunk); in fact, add a small margin all around
# (note: this is not sufficient to enclose all atoms entirely; that's intentional)
margin = 0.2
min_z -= margin
max_z += margin
radius += margin
return (bcenter + min_z * axis, bcenter + max_z * axis, radius, color)
def m2rotaxis(m):
"""
Return angles, axis pair that corresponds to rotation matrix m.
"""
# Angle always between 0 and pi
# Sense of rotation is defined by axis orientation
t=0.5*(trace(m)-1)
t=max(-1, t)
t=min(1, t)
angle=acos(t)
if angle<1e-15:
# Angle is 0
return 0.0, Vector(1,0,0)
elif angle<pi:
# Angle is smaller than pi
x=m[2,1]-m[1,2]
y=m[0,2]-m[2,0]
z=m[1,0]-m[0,1]
axis=Vector(x,y,z)
axis.normalize()
return angle, axis
else:
# Angle is pi - special case!
m00=m[0,0]
m11=m[1,1]
m22=m[2,2]
if m00>m11 and m00>m22:
x=sqrt(m00-m11-m22+0.5)
y=m[0,1]/(2*x)
z=m[0,2]/(2*x)
elif m11>m00 and m11>m22:
y=sqrt(m11-m00-m22+0.5)
x=m[0,1]/(2*y)
z=m[1,2]/(2*y)
else:
z=sqrt(m22-m00-m11+0.5)
x=m[0,2]/(2*z)
y=m[1,2]/(2*z)
axis=Vector(x,y,z)
axis.normalize()
return pi, axis
def test_setWeightedProperty(self):
"""setWeightedProperty should calculate and set correct property"""
leaf_dict = {'d':2, 'e':1, 'g':6, 'h':7}
means_dict = leaf_dict.copy()
c_val = (2.0/1+1.0/4+6.0/2)/(1/1+1.0/4+1.0/2)
delta = 0.01
a_val = (c_val/delta + 7.0/2)/(1.0/delta + 1.0/2)
means_dict.update({'f':6, 'c':c_val, 'b':c_val, 'a':a_val})
c_stdev =sqrt(((2-c_val)**2 +(1-c_val)**2 + (6-c_val)**2)/3)
stdevs_dict = {'d':0, 'e':0, 'g':0, 'f':0, \
'c': c_stdev, 'b':0, 'h':0, \
'a':sqrt(((a_val-c_val)**2+(a_val-7)**2)/2)}
def set_leaf_f(node):
return leaf_dict[node.Data]
r = self.TreeRoot
r.setWeightedProperty(set_leaf_f, 'x', branch_delta=delta)
for node in r.traverse(self_before=False, self_after=True):
self.assertEqual(node.xWeightedMean, means_dict[node.Data])
self.assertFloatEqual(node.xWeightedStdev, stdevs_dict[node.Data])
def writepov(self, file, dispdef):
if self.hidden: return
if self.is_disabled(): return #bruce 050421
c = self.posn()
a = self.axen()
xrot = -atan2(a[1], sqrt(1-a[1]*a[1]))*180/pi
yrot = atan2(a[0], sqrt(1-a[0]*a[0]))*180/pi
file.write("lmotor(" \
+ povpoint([self.width * 0.5, self.width * 0.5, self.length * 0.5]) + "," \
+ povpoint([self.width * -0.5, self.width * -0.5, self.length * -0.5]) + "," \
+ "<0.0, " + str(yrot) + ", 0.0>," \
+ "<" + str(xrot) + ", 0.0, 0.0>," \
+ povpoint(c) + "," \
+ "<" + str(self.color[0]) + "," + str(self.color[1]) + "," + str(self.color[2]) + ">)\n")
for a in self.atoms:
if vlen(c - a.posn()) > 0.001: #bruce 060808 add condition to see if this fixes bug 719 (two places in this file)
file.write("spoke(" + povpoint(c) + "," + povpoint(a.posn()) + "," + str (self.sradius) +
",<" + str(self.color[0]) + "," + str(self.color[1]) + "," + str(self.color[2]) + ">)\n")
def __sub__(self, other):
"""
Calculate distance between two atoms.
Example:
>>> distance=atom1-atom2
@param other: the other atom
@type other: L{Atom}
"""
diff=self.coord-other.coord
return sqrt(sum(diff*diff))
def compute_memo(self, chunk):
"""
If drawing chunk in this display mode can be optimized by precomputing some info from chunk's appearance,
compute that info and return it.
If this computation requires preference values, access them as env.prefs[key],
and that will cause the memo to be removed (invalidated) when that preference value is changed by the user.
This computation is assumed to also depend on, and only on, chunk's appearance in ordinary display modes
(i.e. it's invalidated whenever havelist is). There is not yet any way to change that,
so bugs will occur if any ordinarily invisible chunk info affects this rendering,
and potential optimizations will not be done if any ordinarily visible info is not visible in this rendering.
These can be fixed if necessary by having the real work done within class Chunk's _recompute_ rules,
with this function or drawchunk just accessing the result of that (and sometimes causing its recomputation),
and with whatever invalidation is needed being added to appropriate setter methods of class Chunk.
If the real work can depend on more than chunk's ordinary appearance can, the access would need to be in drawchunk;
otherwise it could be in drawchunk or in this method compute_memo.
"""
# for this example, we'll turn the chunk axes into a cylinder.
# Since chunk.axis is not always one of the vectors chunk.evecs (actually chunk.poly_evals_evecs_axis[2]),
# it's best to just use the axis and center, then recompute a bounding cylinder.
if not chunk.atoms:
return None
axis = chunk.axis
axis = norm(axis) # needed (unless we're sure it's already unit length, which is likely)
center = chunk.center
points = chunk.atpos - center # not sure if basepos points are already centered
# compare following Numeric Python code to findAtomUnderMouse and its caller
matrix = matrix_putting_axis_at_z(axis)
v = dot( points, matrix)
# compute xy distances-squared between axis line and atom centers
r_xy_2 = v[:,0]**2 + v[:,1]**2
## r_xy = sqrt(r_xy_2) # not needed
# to get radius, take maximum -- not sure if max(r_xy_2) would use Numeric code, but this will for sure:
i = argmax(r_xy_2)
max_xy_2 = r_xy_2[i]
radius = sqrt(max_xy_2)
# to get limits along axis (since we won't assume center is centered between them), use min/max z:
z = v[:,2]
min_z = z[argmin(z)]
max_z = z[argmax(z)]
bcenter = chunk.abs_to_base(center)
# return, in chunk-relative coords, end1, end2, and radius of the cylinder, and color.
color = chunk.color
if color is None:
color = V(0.5,0.5,0.5)
# make sure it's longer than zero (in case of a single-atom chunk); in fact, add a small margin all around
# (note: this is not sufficient to enclose all atoms entirely; that's intentional)
margin = 0.2
min_z -= margin
max_z += margin
radius += margin
return (bcenter + min_z * axis, bcenter + max_z * axis, radius, color)
def test_conservation_of_area(self):
"""Test that coefficients in lp satisfy the dilation equation
"""
from daubfilt import daubfilt, number_of_filters
for p in range(number_of_filters):
D = 2*(p+1)
lp, hp = daubfilt(D)
err = abs(sum(lp)-sqrt(2))
#assert abs(err) <= epsilon, 'Error == %e' %err
assert allclose(err, 0), 'Error == %e' %err
def gauss_potential_to_string(l, m, numeric=False):
"""Return string representation of the potential of a generalized
gaussian.
The potential is determined by::
m m ^ _ m ^
v [g (r) Y (r) ](r) = v (r) Y (r)
l l l l l l
where::
4 pi / -l-1 /r l+2 l /oo 1-l \
v (r) = ---- | r | dx x g (r) + r | dx x g (r) |
l 2l+1 \ /0 l /r l /
"""
v_l = [
[Q(4, 1), 1],
[Q(4, 3), 1, 2],
[Q(4, 15), 3, 6, 4],
[Q(4, 105), 15, 30, 20, 8],
[Q(4, 945), 105, 210, 140, 56, 16],
[Q(4, 10395), 945, 1890, 1260, 504, 144, 32],
]
norm, xyzs = Y_collect(l, m)
norm.multiply(v_l[l][0])
string = txt_sqrt(norm.norm, numeric) + "*" + (l != 0) * "("
if numeric:
string += repr(v_l[l][1] * sqrt(pi))
else:
string += str(v_l[l][1]) + "*sqrt(pi)"
string += "*erf(sqrt(a)*r)"
if len(v_l[l]) > 2:
string += "-("
for n, coeff in enumerate(v_l[l][2:]):
if n == 0:
string += str(coeff)
else:
string += "+" + str(coeff) + "*(sqrt(a)*r)**%d" % (2 * n)
string += ")*sqrt(a)*r*exp(-a*r2)"
if l == 0:
string += "/r"
elif l == 1:
string += ")/r/r2*" + to_string(l, xyzs)
else:
string += ")/r/r2**%d*" % l + to_string(l, xyzs)
return string
def gauss_potential_to_string(l, m, numeric=False):
"""Return string representation of the potential of a generalized
gaussian.
The potential is determined by::
m m ^ _ m ^
v [g (r) Y (r) ](r) = v (r) Y (r)
l l l l l l
where::
4 pi / -l-1 /r l+2 l /oo 1-l \
v (r) = ---- | r | dx x g (r) + r | dx x g (r) |
l 2l+1 \ /0 l /r l /
"""
v_l = [
[Q(4, 1), 1],
[Q(4, 3), 1, 2],
[Q(4, 15), 3, 6, 4],
[Q(4, 105), 15, 30, 20, 8],
[Q(4, 945), 105, 210, 140, 56, 16],
[Q(4, 10395), 945, 1890, 1260, 504, 144, 32],
]
norm, xyzs = Y_collect(l, m)
norm.multiply(v_l[l][0])
string = txt_sqrt(norm.norm, numeric) + '*' + (l != 0) * '('
if numeric:
string += repr(v_l[l][1] * sqrt(pi))
else:
string += str(v_l[l][1]) + '*sqrt(pi)'
string += '*erf(sqrt(a)*r)'
if len(v_l[l]) > 2:
string += '-('
for n, coeff in enumerate(v_l[l][2:]):
if n == 0:
string += str(coeff)
else:
string += '+' + str(coeff) + '*(sqrt(a)*r)**%d' % (2 * n)
string += ')*sqrt(a)*r*exp(-a*r2)'
if l == 0:
string += '/r'
elif l == 1:
string += ')/r/r2*' + to_string(l, xyzs)
else:
string += ')/r/r2**%d*' % l + to_string(l, xyzs)
return string
def plot_avg(self,x=None,y=None,title=None,replot=False,step=1,
errorbars='conf'):
"""
Plot the average over a set of Y values with error bars
indicating the 95% confidence interval of the sample mean at
each point. (i.e. stderr * 1.96)
y = A sequence of sequences of Y values to average.
If not all sequences are of equal length, the length
of the shortest sequence is used for all.
x = (optional) A single sequence of X values corresponding to
the Ys.
title = The title of the average plot.
replot = Keep the old contents of the plot window.
default = False
step = Plot the average at every Nth point. (default = 1)
errorbars = What statistic to use for error bars, one of:
'conf' -> 95% confidence interval (stderr * 1.96)
'stderr' -> Standard error
'stddev -> Standard deviation
'var' -> Variance
"""
from Numeric import concatenate as join
N = min(map(len,y))
mean,var,stderr = utils.stats(join([array([a[:N]]) for a in y],axis=0))
if replot:
self.current_style += 1
else:
self.current_style = 1
self.plot(x=x,y=mean,title=title,
with='lines %d'%self.current_style,
step=step,replot=replot)
if not x:
x = range(len(mean))
if errorbars == 'conf':
bars = stderr * 1.96
elif errorbars == 'stderr':
bars = stderr
elif errorbars == 'stddev':
bars = sqrt(var)
elif errorbars == 'var':
bars = var
else:
raise 'Unknown error bar type: "%s"' % errorbars
self.plot(pts=zip(x,mean,bars),with='errorbars %d'%self.current_style,
step=step,replot=1)
def t_one_observation(x, sample, tails=None, exp_diff=0):
"""Returns t-test for significance of single observation versus a sample.
Equation for 1-observation t (Sokal and Rohlf 1995 p 228):
t = obs - mean - exp_diff / (var * sqrt((n+1)/n))
df = n - 1
"""
try:
n = sample.Count
t = (x - sample.Mean - exp_diff)/sample.StandardDeviation/sqrt((n+1)/n)
except (ZeroDivisionError, ValueError, AttributeError, TypeError):
return (None, None)
prob = t_tailed_prob(t, n-1, tails)
return t, prob
def t_one_sample(a,popmean=0, tails=None):
"""Returns t for ONE group of scores a, given a population mean.
Usage: t, prob = t_one_sample(a, popmean, tails)
t is a float; prob is a probability.
a should support Mean, StandardDeviation, and Count.
popmean should be the expected mean; 0 by default.
tails should be None (default), 'high', or 'low'.
"""
try:
n = a.Count
t = (a.Mean - popmean)/(a.StandardDeviation/sqrt(n))
except (ZeroDivisionError, ValueError, AttributeError, TypeError):
return None, None
prob = t_tailed_prob(t, n-1, tails)
return t, prob
def construct_spherical_code(lmax=3):
"""Method for generating the code in gpaw/spherical_harmonics.py"""
YL = []
norms = []
for L in range((lmax+1)**2):
#norm, xyzs = Y_collect(*L_to_lm(L))
norm, xyzs = Y_collect2(*L_to_lm(L))
norms.append(str(norm))
YL.append(zip(xyzs.values(), xyzs.keys()))
print('Y_L = [')
for L, Y in enumerate(YL):
l = sqrt(L)
if l % 1 == 0:
print(' #' + 'spdfghijklmn'[int(l)] + ':')
print(' %s,' % Y)
print(']')
print('norms =', norms)
def weightedMean(data, sigma):
"""Weighted mean of a sequence of numbers with given standard deviations.
|data| is a list of measurements,
|sigma| a list with corresponding standard deviations.
Returns weighted mean and corresponding standard deviation.
"""
from Numeric import array, Float, sqrt, sum
if len(data) != len(sigma):
raise ValueError
data = 1. * Numeric.array(data)
sigma = 1. * Numeric.array(sigma)
nom = sum(data / sigma**2)
denom = sum(1. / sigma**2)
mean = nom / denom
sig = sqrt(1. / denom)
return mean, sig
def construct_spherical_code(lmax=3):
"""Method for generating the code in gpaw/spherical_harmonics.py"""
YL = []
norms = []
for L in range((lmax + 1)**2):
#norm, xyzs = Y_collect(*L_to_lm(L))
norm, xyzs = Y_collect2(*L_to_lm(L))
norms.append(str(norm))
YL.append(zip(xyzs.values(), xyzs.keys()))
print('Y_L = [')
for L, Y in enumerate(YL):
l = sqrt(L)
if l % 1 == 0:
print(' #' + 'spdfghijklmn'[int(l)] + ':')
print(' %s,' % Y)
print(']')
print('norms =', norms)
def test_distance(self):
"""distance: should return correct distance between the profiles
"""
p1 = Profile(array([[2,4],[3,1]]), "AB")
p2 = Profile(array([[4,6],[5,3]]), "AB")
p3 = Profile(array([[4,6],[5,3],[1,1]]), "AB")
p4 = Profile(array([2,2]),"AB")
p5 = Profile(array([2,2,2]),"AB")
p6 = Profile(array([[]]),"AB")
self.assertEqual(p1.distance(p2),4)
self.assertEqual(p2.distance(p1),4)
self.assertEqual(p1.distance(p4),sqrt(6))
self.assertEqual(p6.distance(p6),0)
#Raises error when frames are not aligned
self.assertRaises(ProfileError, p1.distance,p3)
self.assertRaises(ProfileError,p1.distance,p5)
def pca(M):
"Perform PCA on M, return eigenvectors and eigenvalues, sorted."
T, N = shape(M)
# if there are fewer rows T than columns N, use snapshot method
if T < N:
C = dot(M, t(M))
evals, evecsC = eigenvectors(C)
# HACK: make sure evals are all positive
evals = where(evals < 0, 0, evals)
evecs = 1. / sqrt(evals) * dot(t(M), t(evecsC))
else:
# calculate covariance matrix
K = 1. / T * dot(t(M), M)
evals, evecs = eigenvectors(K)
# sort the eigenvalues and eigenvectors, descending order
order = (argsort(evals)[::-1])
evecs = take(evecs, order, 1)
evals = take(evals, order)
return evals, t(evecs)
def init_icos():
global icosa, icosix
# the golden ratio
global phi
phi = (1.0 + sqrt(5.0)) / 2.0
vert = norm(V(phi, 0, 1))
a = vert[0]
b = vert[1]
c = vert[2]
# vertices of an icosahedron
icosa = ((-a, b, c), (b, c, -a), (b, c, a), (a, b, -c), (-c, -a, b),
(-c, a, b), (b, -c, a), (c, a, b), (b, -c, -a), (a, b, c),
(c, -a, b), (-a, b, -c))
icosix = ((9, 2, 6), (1, 11, 5), (11, 1, 8), (0, 11, 4), (3, 1, 7),
(3, 8, 1), (9, 3, 7), (0, 6, 2), (4, 10, 6), (1, 5, 7),
(7, 5, 2), (8, 3, 10), (4, 11, 8), (9, 7, 2), (10, 9, 6),
(0, 5, 11), (0, 2, 5), (8, 10, 4), (3, 9, 10), (6, 0, 4))
return
def findHandles_exact(self,
p1,
p2,
cutoff=0.0,
backs_ok=1,
offset=V(0, 0, 0)):
"""
@return: a list of (dist, handle) pairs, in arbitrary order, which
includes, for each handle (spherical surface) hit by the ray from p1
thru p2, its front-surface intersection with the ray, unless that has
dist < cutoff and backs_ok, in which case include its back-surface
intersection (unless *that* has dist < cutoff).
"""
#e For now, just be simple, don't worry about speed.
# Someday we can preprocess self.handlpos using Numeric functions,
# like in nearSinglets and/or findSinglets
# (I have untested prototype code for this in extrude-outs.py).
hh = self.handles
res = []
v = norm(p2 - p1)
# is this modifying the vector in-place, causing a bug??
## offset += self.origin # treat our handles' pos as relative to this
# I don't know, but one of the three instances of += was doing this!!!
# probably i was resetting the atom or mol pos....
offset = offset + self.origin # treat our handles' pos as relative to this
radius_multiplier = self.radius_multiplier
for (pos, radius, info) in hh:
## bug in this? pos += offset
pos = pos + offset
radius *= radius_multiplier
dist, wid = orthodist(p1, v, pos)
if radius >= wid: # the ray hits the sphere
delta = sqrt(radius * radius - wid * wid)
front = dist - delta # depth from p1 of front surface of sphere, where it's hit
if front >= cutoff:
res.append((front, (pos, radius, info)))
elif backs_ok:
back = dist + delta
if back >= cutoff:
res.append((back, (pos, radius, info)))
return res
def pca(M):
from Numeric import take, dot, shape, argsort, where, sqrt, transpose as t
from LinearAlgebra import eigenvectors
"Perform PCA on M, return eigenvectors and eigenvalues, sorted."
T, N = shape(M)
# if there are less rows T than columns N, use
# snapshot method
if T < N:
C = dot(M, t(M))
evals, evecsC = eigenvectors(C)
# HACK: make sure evals are all positive
evals = where(evals < 0, 0, evals)
evecs = 1./sqrt(evals) * dot(t(M), t(evecsC))
else:
# calculate covariance matrix
K = 1./T * dot(t(M), M)
evals, evecs = eigenvectors(K)
# sort the eigenvalues and eigenvectors, decending order
order = (argsort(evals)[::-1])
evecs = take(evecs, order, 1)
evals = take(evals, order)
return evals, t(evecs)
def scale(self):
"""
Return the maximum distance from self's geometric center
to any point in self (i.e. the corner-center distance).
Note: This is the radius of self's bounding sphere,
which is as large as, and usually larger than, the
bounding sphere of self's contents.
Note: self's box dimensions are slightly larger than
needed to enclose its data, due to hardcoded constants
in its construction methods. [TODO: document, make optional]
"""
if not self.data: return 10.0
#x=1.2*maximum.reduce(subtract.reduce(self.data))
dd = 0.5 * subtract.reduce(self.data)
# dd = halfwidths in each dimension (x,y,z)
x = sqrt(dd[0] * dd[0] + dd[1] * dd[1] + dd[2] * dd[2])
# x = half-diameter of bounding sphere of self
#return max(x, 2.0)
return x
def L_to_lm(L):
"""convert L index to (l, m) index"""
l = int(sqrt(L))
m = L - l**2 - l
return l, m
def __float__(self):
return sqrt(self.norm / pi)
def _dist(p, q):
diff = p - q
return sqrt(sum(diff * diff))
def norm(x):
return sqrt(dot(x, x))
def _buildResiduum(self, mol, zmatrix, n_atoms, phi, psi, init_pos,
symbol):
"""
Builds cartesian coordinates for an amino acid from the internal
coordinates table.
mol is a chunk to which the amino acid will be added.
zmatrix is an internal coordinates array corresponding to a given amino acid.
n_atoms is a number of atoms to be build + 3 dummy atoms.
phi is a peptide bond PHI angle.
psi is a peptide bond PSI angle.
init_pos are optional postions of previous CA, C and O atoms.
symbol is a current amino acid symbol (used for proline case)
Note: currently, it doesn't rebuild bonds, so inferBonds has to be called after.
Unfortunately, the proper bond order can not be correctly recognized this way.
"""
if mol == None:
return
if not init_pos: # assign three previous atom positions
for i in range(0, 3):
self.coords[i][0] = self.prev_coords[i][0]
self.coords[i][1] = self.prev_coords[i][1]
self.coords[i][2] = self.prev_coords[i][2]
else: # if no prev_coords are given, compute the first three atom positions
num, name, atom_name, atom_type, \
atom_c, atom_b, atom_a, r, a, t = zmatrix[1]
self.coords[0][0] = 0.0
self.coords[0][1] = 0.0
self.coords[0][2] = 0.0
self.coords[1][0] = r
self.coords[1][1] = 0.0
self.coords[1][2] = 0.0
ccos = cos(DEG2RAD * a)
num, name, atom_name, atom_type, \
atom_c, atom_b, atom_a, r, a, t = zmatrix[2]
if atom_c == 1:
self.coords[2][0] = self.coords[0][0] + r * ccos
else:
self.coords[2][0] = self.coords[0][0] - r * ccos
self.coords[2][1] = r * sin(DEG2RAD * a)
self.coords[2][2] = 0.0
for i in range(0, 3):
self.prev_coords[i][0] = self.coords[i][0] + init_pos[0]
self.prev_coords[i][1] = self.coords[i][1] + init_pos[1]
self.prev_coords[i][2] = self.coords[i][2] + init_pos[2]
for n in range(3, n_atoms):
# Generate all coordinates using three previous atoms
# as a frame of reference,
num, name, atom_name, atom_type, \
atom_c, atom_b, atom_a, r, a, t = zmatrix[n]
cosa = cos(DEG2RAD * a)
xb = self.coords[atom_b][0] - self.coords[atom_c][0]
yb = self.coords[atom_b][1] - self.coords[atom_c][1]
zb = self.coords[atom_b][2] - self.coords[atom_c][2]
rbc = 1.0 / sqrt(xb * xb + yb * yb + zb * zb)
if abs(cosa) >= 0.999:
# Linear bond case
# Skip angles, just extend along the bond.
rbc = r * rbc * cosa
self.coords[n][0] = self.coords[atom_c][0] + xb * rbc
self.coords[n][1] = self.coords[atom_c][1] + yb * rbc
self.coords[n][2] = self.coords[atom_c][2] + zb * rbc
else:
xa = self.coords[atom_a][0] - self.coords[atom_c][0]
ya = self.coords[atom_a][1] - self.coords[atom_c][1]
za = self.coords[atom_a][2] - self.coords[atom_c][2]
xyb = sqrt(xb * xb + yb * yb)
inv = False
if xyb < 0.001:
xpa = za
za = -xa
xa = xpa
xpb = zb
zb = -xb
xb = xpb
xyb = sqrt(xb * xb + yb * yb)
inv = True
costh = xb / xyb
sinth = yb / xyb
xpa = xa * costh + ya * sinth
ypa = ya * costh - xa * sinth
sinph = zb * rbc
cosph = sqrt(abs(1.0 - sinph * sinph))
xqa = xpa * cosph + za * sinph
zqa = za * cosph - xpa * sinph
yza = sqrt(ypa * ypa + zqa * zqa)
if yza < 1e-8:
coskh = 1.0
sinkh = 0.0
else:
coskh = ypa / yza
sinkh = zqa / yza
# Apply the peptide bond conformation
if symbol != "P":
if name == "N " and not init_pos:
t = self.prev_psi + 0.0
if name == "O ":
t = psi + 180.0
if name == "HA " or name == "HA2":
t = 120.0 + phi
if name == "CB " or name == "HA3":
t = 240.0 + phi
if name == "C ":
t = phi
else:
# proline
if name == "N " and not init_pos:
t = self.prev_psi + 0.0
if name == "O ":
t = psi + 180.0
if name == "CA ":
t = phi - 120.0
if name == "CD ":
t = phi + 60.0
sina = sin(DEG2RAD * a)
sind = -sin(DEG2RAD * t)
cosd = cos(DEG2RAD * t)
# Apply the bond length.
xd = r * cosa
yd = r * sina * cosd
zd = r * sina * sind
# Compute the atom position using bond and torsional angles.
ypd = yd * coskh - zd * sinkh
zpd = zd * coskh + yd * sinkh
xpd = xd * cosph - zpd * sinph
zqd = zpd * cosph + xd * sinph
xqd = xpd * costh - ypd * sinth
yqd = ypd * costh + xpd * sinth
if inv:
tmp = -zqd
zqd = xqd
xqd = tmp
self.coords[n][0] = xqd + self.coords[atom_c][0]
self.coords[n][1] = yqd + self.coords[atom_c][1]
self.coords[n][2] = zqd + self.coords[atom_c][2]
if self.nterm_hydrogen:
# It is a hack for the first hydrogen atom
# to make sure the bond length is correct.
self.nterm_hydrogen.setposn(self.nterm_hydrogen.posn() +
0.325 * norm(V(xqd, yqd, zqd)))
self.nterm_hydrogen = None
ax = self.coords[n][0]
ay = self.coords[n][1]
az = self.coords[n][2]
# Store previous coordinates for the next building step
if not init_pos:
if name == "N ":
self.prev_coords[0][0] = self.coords[n][0]
self.prev_coords[0][1] = self.coords[n][1]
self.prev_coords[0][2] = self.coords[n][2]
if name == "CA ":
self.prev_coords[1][0] = self.coords[n][0]
self.prev_coords[1][1] = self.coords[n][1]
self.prev_coords[1][2] = self.coords[n][2]
if name == "C ":
self.prev_coords[2][0] = self.coords[n][0]
self.prev_coords[2][1] = self.coords[n][1]
self.prev_coords[2][2] = self.coords[n][2]
# Add a new atom to the molecule
atom = Atom(
atom_name,
V(self.coords[n][0], self.coords[n][1], self.coords[n][2]),
mol)
# Create temporary attributes for proper bond assignment.
atom._is_aromatic = False
atom._is_single = False
if atom_type == "sp2a":
atom_type = "sp2"
atom._is_aromatic = True
if atom_type == "sp2s":
atom_type = "sp2"
atom._is_single = True
atom.set_atomtype_but_dont_revise_singlets(atom_type)
if name == "CA ":
# Set c-alpha flag for protein main chain visualization.
atom._protein_ca = True
else:
atom._protein_ca = False
if name == "CB ":
# Set c-alpha flag for protein main chain visualization.
atom._protein_cb = True
else:
atom._protein_cb = False
if name == "N ":
# Set c-alpha flag for protein main chain visualization.
atom._protein_n = True
else:
atom._protein_n = False
if name == "C ":
# Set c-alpha flag for protein main chain visualization.
atom._protein_c = True
else:
atom._protein_c = False
if name == "O ":
# Set c-alpha flag for protein main chain visualization.
atom._protein_o = True
else:
atom._protein_o = False
# debug - output in PDB format
# print "ATOM %5d %-3s %3s %c%4d %8.3f%8.3f%8.3f" % ( n, name, "ALA", ' ', res_num, coords[n][0], coords[n][1], coords[n][2])
self.prev_psi = psi # Remember previous psi angle.
self.length += 1 # Increase the amino acid counter.
return
def L2norm(ar):
from Numeric import dot, sqrt
return sqrt(sum(ar**2))
#!/usr/bin/python
# -*- coding: utf-8 -*-
from scipy.signal.ltisys import lti, lsim
from matplotlib.pylab import save, randn
from Numeric import sqrt, array, arange
n = 128
Q = 1.
R = 1.
w = 0.3 * sqrt(Q) * randn(n)
v = 0.2 * sqrt(R) * randn(n)
ureq = array([[-1.743] * n])
t = arange(0, 0.9999, 1. / 128)
#Generator().generateSin(n, 3, 33) #-0.37727
u = ureq + w
#A, B, C, D = [[-6.,-25.], [1.,0.]], [[1.],[0.]], [[0., 1.]], [[0.]]
#sys=lti(A, B, C, D)
#y = lsim(sys, u, t)
yv = u + v
##save('Q.txt', Q)
##save('R.txt', R)
save('w.txt', w)
save('v.txt', v)
save('yv.txt', yv)
save('u.txt', u)
save('ureq.txt', ureq)
def addInternal(self, i, na, nb, nc, r, theta, phi):
"""
Add another point, given its internal coordinates. Once added
via this routine, the cartesian coordinates for the point can
be retrieved with getCartesian().
@param i: Index of the point being added. After this call, a
call to getCartesian with this index value will
succeed. Index values less than 4 are ignored.
Index values should be presented here in sequence
beginning with 4.
@param na: Index value for point A. Point 'i' will be 'r'
distance units from point A.
@param nb: Index value for point B. Point 'i' will be located
such that the angle i-A-B is 'theta' degrees.
@param nc: Index value for point C. Point 'i' will be located
such that the torsion angle i-A-B-C is 'torsion'
degrees.
@param r: Radial distance (in same units as resulting
cartesian coordinates) between A and i.
@param theta: Angle in degrees of i-A-B.
@param phi: Torsion angle in degrees of i-A-B-C
"""
if (i < 4):
return
if (i != self._nextIndex):
raise IndexError, "next index is %d not %r" % (self._nextIndex, i)
cos_theta = cos(DEG2RAD * theta)
xb = self._coords[nb][0] - self._coords[na][0]
yb = self._coords[nb][1] - self._coords[na][1]
zb = self._coords[nb][2] - self._coords[na][2]
rba = 1.0 / sqrt(xb*xb + yb*yb + zb*zb)
if abs(cos_theta) >= 0.999:
# Linear case
# Skip angles, just extend along A-B.
rba = r * rba * cos_theta
xqd = xb * rba
yqd = yb * rba
zqd = zb * rba
else:
xc = self._coords[nc][0] - self._coords[na][0]
yc = self._coords[nc][1] - self._coords[na][1]
zc = self._coords[nc][2] - self._coords[na][2]
xyb = sqrt(xb*xb + yb*yb)
inv = False
if xyb < 0.001:
# A-B points along the z axis.
tmp = zc
zc = -xc
xc = tmp
tmp = zb
zb = -xb
xb = tmp
xyb = sqrt(xb*xb + yb*yb)
inv = True
costh = xb / xyb
sinth = yb / xyb
xpc = xc * costh + yc * sinth
ypc = yc * costh - xc * sinth
sinph = zb * rba
cosph = sqrt(abs(1.0- sinph * sinph))
xqa = xpc * cosph + zc * sinph
zqa = zc * cosph - xpc * sinph
yzc = sqrt(ypc * ypc + zqa * zqa)
if yzc < 1e-8:
coskh = 1.0
sinkh = 0.0
else:
coskh = ypc / yzc
sinkh = zqa / yzc
sin_theta = sin(DEG2RAD * theta)
sin_phi = -sin(DEG2RAD * phi)
cos_phi = cos(DEG2RAD * phi)
# Apply the bond length.
xd = r * cos_theta
yd = r * sin_theta * cos_phi
zd = r * sin_theta * sin_phi
# Compute the atom position using bond and torsional angles.
ypd = yd * coskh - zd * sinkh
zpd = zd * coskh + yd * sinkh
xpd = xd * cosph - zpd * sinph
zqd = zpd * cosph + xd * sinph
xqd = xpd * costh - ypd * sinth
yqd = ypd * costh + xpd * sinth
if inv:
tmp = -zqd
zqd = xqd
xqd = tmp
self._coords[i][0] = xqd + self._coords[na][0]
self._coords[i][1] = yqd + self._coords[na][1]
self._coords[i][2] = zqd + self._coords[na][2]
self._nextIndex = self._nextIndex + 1
# | . .
# | . .
# | . .
# | . .
# sic_yU -(0) . . . . . (2) (5)
# | . .
# | . .
# | . .
# | . .
# | . .
# 0 --+------+------|-----(1)-----|-----(6)-----|---
# | | | |
# 0 sic_uLen 2*sic_uLen 3*sic_uLen
#
sic_uLen = 1.8 # Si-C bond length (I think)
sic_yU = sic_uLen * sqrt(3.0) / 2
sic_vpdat = [[0.0 * sic_uLen, 1.0 * sic_yU, 0.0],
[1.5 * sic_uLen, 0.0 * sic_yU, 0.0],
[1.0 * sic_uLen, 1.0 * sic_yU, 0.0],
[1.5 * sic_uLen, 2.0 * sic_yU, 0.0],
[2.5 * sic_uLen, 2.0 * sic_yU, 0.0],
[3.0 * sic_uLen, 1.0 * sic_yU, 0.0],
[2.5 * sic_uLen, 0.0 * sic_yU, 0.0]]
def setup_draw_grid_lines():
"""
This must be called in whichever GL display list context will be drawn in.
See comment in drawer.setup_drawer about problems with calling this
in more than one GL context. For now, it shouldn't be.