def test_quats():
for x, y, z in euler_tuples:
M1 = ttb.euler2mat(z, y, x)
quatM = tq.mat2quat(M1)
quat = ttb.euler2quat(z, y, x)
assert tq.nearly_equivalent(quatM, quat)
quatS = sympy_euler2quat(z, y, x)
assert tq.nearly_equivalent(quat, quatS)
zp, yp, xp = ttb.quat2euler(quat)
# The parameters may not be the same as input, but they give the
# same rotation matrix
M2 = ttb.euler2mat(zp, yp, xp)
assert_array_almost_equal(M1, M2)
def test_euler_imps():
for x, y, z in euler_tuples:
M1 = tg.euler_matrix(z, y, x, 'szyx')[:3, :3]
M2 = ttb.euler2mat(z, y, x)
assert_array_almost_equal(M1, M2)
q1 = tg.quaternion_from_euler(z, y, x, 'szyx')
q2 = ttb.euler2quat(z, y, x)
assert tq.nearly_equivalent(q1, q2)
def average_anisotropic_tensor(ndat, vq, qframe=(1,0,0,0)):
"""
The input vector vq has shape (ndat, 3), and we require the np.outer operation.
This np.outer operation is replaced by an einstein summation shep to speed up calculations.
"""
# Check if there is no rotation.
if not qops.nearly_equivalent(qframe,(1,0,0,0)):
vq = qs.rotate_vector_simd( vq, qframe, axis=-1)
return np.mean( np.einsum('ij,ik->ijk', vq, vq), axis=0 )
def test_axis_angle():
for M, q in eg_pairs:
vec, theta = tq.quat2axangle(q)
q2 = tq.axangle2quat(vec, theta)
assert tq.nearly_equivalent(q, q2)
aa_mat = taa.axangle2mat(vec, theta)
assert_array_almost_equal(aa_mat, M)
aa_mat2 = sympy_aa2mat(vec, theta)
assert_array_almost_equal(aa_mat, aa_mat2)
aa_mat22 = sympy_aa2mat2(vec, theta)
assert_array_almost_equal(aa_mat, aa_mat22)
def average_anisotropic_tensor_old(vq, qframe=(1,0,0,0)):
ndat=vq.shape[0]
out=np.zeros((3,3))
if qops.nearly_equivalent(qframe,(1,0,0,0)):
for i in range(ndat):
out+=np.outer(vq[i],vq[i])
else:
for i in range(ndat):
vrot=qops.rotate_vector(vq[i],qframe)
out+=np.outer(vrot,vrot)
return out/ndat
def average_anisotropic_tensor(vq, qframe=(1,0,0,0)):
"""
Given the list of N components of q_v in te shape of (N,3)
Calculates the average tensor < q_i q_j >, i,j={x,y,z}
"""
ndat=vq.shape[0]
#print "= = Debug: vq shape", vq.shape
# Check if there is no rotation.
if not qops.nearly_equivalent(qframe,(1,0,0,0)):
vq=qs.rotate_vector_simd(vq, qframe)
return np.einsum('ij,ik->jk', vq, vq) / ndat
def test_axis_angle():
for M, q in eg_pairs:
vec, theta = tq.quat2axangle(q)
q2 = tq.axangle2quat(vec, theta)
assert tq.nearly_equivalent(q, q2)
aa_mat = taa.axangle2mat(vec, theta)
assert_array_almost_equal(aa_mat, M)
aa_mat2 = sympy_aa2mat(vec, theta)
assert_array_almost_equal(aa_mat, aa_mat2)
aa_mat22 = sympy_aa2mat2(vec, theta)
assert_array_almost_equal(aa_mat, aa_mat22)
def test_quaternion_imps():
for x, y, z in euler_tuples:
M = ttb.euler2mat(z, y, x)
quat = tq.mat2quat(M)
# Against transformations code
tM = tg.quaternion_matrix(quat)
assert_array_almost_equal(M, tM[:3, :3])
M44 = np.eye(4)
M44[:3, :3] = M
tQ = tg.quaternion_from_matrix(M44)
assert tq.nearly_equivalent(quat, tQ)
#chunk_moilist=np.zeros((num_chunk,tot_int,3,3))
index=0
for delta in range(min_int,max_int+1,skip_int):
time_delta=delta*data_delta_t
#Gather the individual samples of angular displacements.
num_nd=ndat-delta
v_dq=obtain_self_dq(data[1:5].T, delta )[...,1:4]
#v_dq=obtain_v_dqs(num_nd, delta, data[1:5].T)
#Isotropic diffusion, use theta_q
iso_sum1=average_LegendreP1quat(num_nd, v_dq)
#Anisotropic Diffusion. Need tensor of vq
moi=average_anisotropic_tensor(num_nd, v_dq)
if not qops.nearly_equivalent(q_frame,(1,0,0,0)):
moiR1=average_anisotropic_tensor(num_nd, v_dq, q_frame)
else:
moiR1=moi
print( " = = %i of %i intervals summed." % ((delta-min_int)/skip_int+1, tot_int) )
#Append to overall list in next outer loop.
out_dtlist[index]=time_delta
if bDoIso:
out_isolist[index]=iso_sum1
if bDoAniso:
eigval, eigvec = np.linalg.eigh(moi)
#Numpy returns the axes as column vectors.
moi_axes=eigvec.T
if False:
debug_orthogonality(moi_axes)
def test_qexp_qlog():
# Test round trip
for unit_quat in unit_quats:
assert tq.nearly_equivalent(tq.qlog(tq.qexp(unit_quat)), unit_quat)
assert tq.nearly_equivalent(tq.qexp(tq.qlog(unit_quat)), unit_quat)