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 test_0_0_0(self):
""" wedge, chi = 0 """
SANITY = False
om = np.zeros(self.np, np.float)
g_old = transform.compute_g_vectors(self.tth,
self.eta,
om,
self.wvln,
wedge=0.0,
chi=0.0)
if SANITY: print g_old.shape, g_old[:, 0]
k = transform.compute_k_vectors(self.tth, self.eta, self.wvln)
if SANITY: print "k=", k[:, 0]
g_new = gv_general.k_to_g(k, om)
if SANITY: print g_new.shape, g_new[:, 0]
if SANITY: print "end routine"
self.assertAlmostEqual(array_diff(g_new, g_old), 0, 6)
def test_0_0(self):
""" wedge, chi = 0 """
SANITY = False
if SANITY: print("*" * 80)
om = np.zeros(self.np, np.float)
g_old = transform.compute_g_vectors(self.tth,
self.eta,
self.omega,
self.wvln,
wedge=0.0,
chi=0.0)
if SANITY: print(g_old.shape, g_old[:, :3])
k = transform.compute_k_vectors(self.tth, self.eta, self.wvln)
if SANITY: print("k=", k[:, :3])
g_new = gv_general.k_to_g(k, self.omega, axis=[0, 0, -1])
if SANITY: print(g_new.shape, g_new[:, :3])
if SANITY: print("end routine")
if SANITY: print("*" * 80)
self.assertAlmostEqual(array_diff(g_new, g_old), 0, 6)
def test_25_30(self):
""" wedge, chi = 25,30 """
w, c = 25, 30
SANITY = False
if SANITY: print "*" * 80
om = np.zeros(self.np, np.float)
g_old = transform.compute_g_vectors(self.tth,
self.eta,
self.omega,
self.wvln,
wedge=w,
chi=c)
if SANITY: print g_old.shape, "\n", g_old[:, :3]
k = transform.compute_k_vectors(self.tth, self.eta, self.wvln)
if SANITY: print "k=", k[:, :3]
post = gv_general.chiwedge(chi=c, wedge=w)
g_new = gv_general.k_to_g(k, self.omega, axis=[0, 0, -1], post=post)
if SANITY: print g_new.shape, g_new[:, :3]
if SANITY: print "end routine"
if SANITY: print "*" * 80
self.assertAlmostEqual(array_diff(g_new, g_old), 0, 6)
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
