def test_0_10(self):
""" wedge,chi = 0,10 """
w = 0.
c = 10.
g = transform.compute_g_vectors(self.tth,
self.eta,
self.omega,
self.wvln,
wedge=w,
chi=c)
post = gv_general.wedgechi(wedge=w, chi=c)
sol1, sol2, valid = gv_general.g_to_k(
g, #
self.wvln,
axis=np.array([0, 0, -1], np.float),
pre=None,
post=post)
c0 = np.cos(transform.radians(self.omega))
c1 = np.cos(transform.radians(sol1))
c2 = np.cos(transform.radians(sol2))
s0 = np.sin(transform.radians(self.omega))
s1 = np.sin(transform.radians(sol1))
s2 = np.sin(transform.radians(sol2))
err1 = np.absolute(c1 - c0) + np.absolute(s1 - s0)
err2 = np.absolute(c2 - c0) + np.absolute(s2 - s0)
err = np.minimum(err1, err2)
self.assertAlmostEqual(array_diff(err, np.zeros(self.np)), 0, 6)
def uncompute_g_vectors(g, wavelength, wedge=0.0, chi=0.0):
"""
Given g-vectors compute tth,eta,omega
assert uncompute_g_vectors(compute_g_vector(tth,eta,omega))==tth,eta,omega
"""
if wedge == chi == 0:
post = None
else:
post = gv_general.wedgechi(wedge=wedge, chi=chi)
omega1, omega2, valid = gv_general.g_to_k(g,
wavelength,
axis=[0, 0, -1],
pre=None,
post=post)
# we know g, omega. Compute k as ... ?
if post is None:
pre = None
else:
pre = gv_general.chiwedge(wedge=wedge, chi=chi).T
k_one = gv_general.k_to_g(g, omega1, axis=[0, 0, 1], pre=pre, post=None)
k_two = gv_general.k_to_g(g, omega2, axis=[0, 0, 1], pre=pre, post=None)
#
# k[1,:] = -ds*c*sin(eta)
# ------ ------------- .... tan(eta) = -k1/k2
# k[2,:] = ds*c*cos(eta)
#
eta_one = np.arctan2(-k_one[1, :], k_one[2, :])
eta_two = np.arctan2(-k_two[1, :], k_two[2, :])
#
#
ds = np.sqrt(np.sum(g * g, 0))
s = ds * wavelength / 2.0 # sin theta
tth = np.degrees(np.arcsin(s) * 2.) * valid
eta1 = np.degrees(eta_one) * valid
eta2 = np.degrees(eta_two) * valid
omega1 = omega1 * valid
omega2 = omega2 * valid
return tth, [eta1, eta2], [omega1, omega2]
def Dcalc(UB, hkls, wedge, chi, wavelength, etao, omega):
"""
Finds "C"alculated 2thetac, etac, omegac for a grain
(Note that these do not depend on the grain position)
UB = 3x3 UB matrix
hkls = 3xn list of peaks (normally integers)
wedge = tilt around y under rotation axis
chi = tilt around beam under rotation axis
wavelength = of the radiation, scales UB
etao = observed azimuth values (angle on powder ring)
omega = observed(?) sample rotation angles
??? ysign determines which solution (there are usually two)
"""
# computed g-vectors
g = np.dot(UB, hkls)
assert g.dtype == float
if 0:
print(g.shape)
print(hkls.shape)
for i in range(10):
print(g[:, i], end=' ')
print(hkls[:, i], end=' ')
print(np.dot(np.linalg.inv(UB), g[:, i]))
# wedge/chi matrix for axis orientation
wc = gv_general.wedgechi(wedge=wedge, chi=chi)
assert wc.dtype == float
# computed omega angles for reflections
omega1, omega2, valid = gv_general.g_to_k(g,
wavelength,
axis=[0, 0, -1],
pre=None,
post=wc)
assert omega1.dtype == float
# hum - isn't this wc-1 ?
cwT = gv_general.chiwedge(wedge=wedge, chi=chi).T
# k vectors, scattering in laboratory at angle omega1/2
k1 = gv_general.k_to_g(g, omega1, axis=[0, 0, 1], pre=cwT, post=None)
k2 = gv_general.k_to_g(g, omega2, axis=[0, 0, 1], pre=cwT, post=None)
assert k1.dtype == float
# Computed azimuth angles
#
# k[1,:] = -ds*c*sin(eta)
# ------ ------------- .... tan(eta) = -k1/k2
# k[2,:] = ds*c*cos(eta)
#
eta_one = np.degrees(np.arctan2(-k1[1, :], k1[2, :]))
eta_two = np.degrees(np.arctan2(-k2[1, :], k2[2, :]))
#
# We select the one matching the observed data
# FIXME - doesn't make sense to do this here
# pick the solution which is closest to matching in eta/omega
d1 = angmod(eta_one - etao)
d2 = angmod(eta_two - etao)
# Selecting which is the computed value for peaks
etac = np.where(abs(d1) < abs(d2), eta_one, eta_two)
omegac = np.where(abs(d1) < abs(d2), omega1, omega2)
if TESTING > 2:
err = abs(etac - etao)
for i in range(len(err)):
if err[i] < 1:
continue
print(i, eta_one[i], eta_two[i], omega1[i], omega2[i])
print("\t", etao[i], omega[i], etac[i], omegac[i])
# Two theta angles
mod_g = np.sqrt((g * g).sum(axis=0))
tthc = np.degrees(2 * np.arcsin(wavelength * mod_g / 2))
# Return computed values (no derivatives here)
return tthc, etac, omegac
print "gve[0] gve[1] gve[2] om1py om2py om1af om2af omtrue"
gve = transform.compute_g_vectors( tth, eta, omega, wvln, wedge, chi )
gve = gve.T.copy()
post = gv_general.chiwedge( wedge=wedge, chi=chi )
posti = np.dot(gv_general.wedgemat(wedge), gv_general.chimat(chi)).T
# don't try to match this as it is wrong!!
# tth, eta, omega = transform.uncompute_g_vectors( hkl.T, wvln,
# wedge=wedge,
# chi = chi)
ppre = np.reshape(pre,(3,3))
ppost = np.reshape(post,(3,3))
omg1, omg2, valid = gv_general.g_to_k( gve.T, wvln, axis=axis, pre=ppre, post=ppost )
#print pre
#print posti.ravel()
#print axis
#print wvln
for i in range(len(gve)):
print "%8.4f%8.4f%8.4f"%tuple(gve[i]),
print "%9.3f %9.3f"%(omg1[i], omg2[i]),
#print gve.T[i],
om1, om2 = wripaca.omegacalc( gve[i], pre, posti.ravel(), axis, wvln )
print "%9.3f %9.3f"%(om1*180/np.pi, om2*180/np.pi), omega[i]
error =min( abs(anglediff( omega[i]*np.pi/180, om1 )), \
abs(anglediff( omega[i]*np.pi/180, om2 ) ))
assert error < 1e-15
# print error
