def compute_gv(self,g):
"""
Makes self.gv refer be g-vectors computed for this grain in this scan
"""
try:
xc = self.scantitles.index("xc")
except:
print(self.scantitles)
raise
# print self.scandata[scanname].shape
x = self.scandata[:,xc]
yc = self.scantitles.index("yc")
y = self.scandata[:,yc]
om = self.scantitles.index("omega")
om = self.scandata[:,om]
tth,eta = transform.compute_tth_eta( np.array([x, y]) ,
self.parameters['y-center'],
self.parameters['y-size'],
self.parameters['tilt-y'],
self.parameters['z-center'],
self.parameters['z-size'],
self.parameters['tilt-z'],
self.parameters['distance']*1.0e3,
crystal_translation = g.translation,
omega = om,
axis_orientation1 = self.parameters['wedge'],
axis_orientation2 = self.parameters['chi'])
self.gv = transform.compute_g_vectors(tth,eta,om,
float(self.parameters['wavelength']),
self.parameters['wedge'])
self.gv = np.transpose(self.gv)
def runTest(self):
tth, eta = transform.compute_tth_eta_from_xyz(self.XLYLZL,
self.omega *
self.omegasign,
t_x=self.t_x,
t_y=self.t_y,
t_z=self.t_z,
wedge=self.wedge,
chi=self.chi)
gve1 = transform.compute_g_vectors(tth,
eta,
self.omega * self.omegasign,
self.wvln,
wedge=self.wedge,
chi=self.chi)
t = np.array((self.t_x, self.t_y, self.t_z))
gve2 = np.empty((len(tth), 3), np.float)
cImageD11.compute_gv(self.XLYLZLT, self.omega, self.omegasign,
self.wvln, self.wedge, self.chi, t, gve2)
# print t, self.wedge,self.chi
# for i in range( len(tth)):
# print i, gve1[:,i],gve1[:,i]-gve2[i],gve1[:,i]-gve3[:,i]
# print "Test C"
self.assertTrue(np.allclose(gve1, gve2.T))
# print "Test Fortran"
if TEST_FORTRAN:
gve3 = np.empty((3, len(tth)), np.float, order='F')
fImageD11.compute_gv(self.XLYLZL, self.omega, self.omegasign,
self.wvln, self.wedge, self.chi, t, gve3)
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 get_hkl(self, event):
# canvas x and y take the screen coords from the event and translate
# them into the coordinate system of the canvas object
xpos = self.canvasObject.canvasx(event.x) / self.zoom
ypos = self.canvasObject.canvasy(event.y) / self.zoom
print "xpos,ypos", xpos, ypos
from ImageD11 import transform
tth, eta = transform.compute_tth_eta(np.array([[xpos], [ypos]]),
**self.parameters)
print "omega:", self.omega, type(self.omega)
om = np.array([float(self.omega)])
print "tth,eta,om", tth, eta, om
self.gv = transform.compute_g_vectors(
tth, eta, om, float(self.parameters['wavelength']),
self.parameters['wedge'])
self.gv = np.transpose(self.gv)
s = ""
i = 0
for ubi in self.ubisread:
h = np.dot(ubi, self.gv.T)
print "i=%d" % (i), "hkl= %.2f %.2f %.2f" % tuple(h)
i += 1
s += "grain %3d\n h = %.2f k=%.2f l = %.2f\n" % (i, h[0], h[1],
h[2])
showinfo(
"Right clicked",
"You click at %f %f, tth=%f eta=%f omega=%f\n %s" %
(xpos, ypos, tth, eta, om, s))
def updatecolfile(self):
if "xl" not in self.cf.titles:
if "sc" in self.cf.titles:
pks = self.cf.sc, self.cf.fc
elif "xc" in self.cf.titles:
pks = self.cf.xc, self.cf.yc
else:
raise Exception("peaks file misses xc or sc")
xl,yl,zl = transform.compute_xyz_lab( pks,
**self.transformpars.parameters)
self.cf.addcolumn(xl,"xl")
self.cf.addcolumn(yl,"yl")
self.cf.addcolumn(zl,"zl")
peaks_xyz = np.array((self.cf.xl,self.cf.yl,self.cf.zl))
om = self.cf.omega
sign = self.transformpars.get("omegasign")
tth, eta = transform.compute_tth_eta_from_xyz(
peaks_xyz, om*sign,
**self.transformpars.parameters)
self.cf.addcolumn( tth, "tth", )
self.cf.addcolumn( eta, "eta", )
gx, gy, gz = transform.compute_g_vectors(
tth, eta, om*sign,
wvln = self.transformpars.get("wavelength"),
wedge = self.transformpars.get("wedge"),
chi = self.transformpars.get("chi") )
self.cf.addcolumn(gx, "gx")
self.cf.addcolumn(gy, "gy")
self.cf.addcolumn(gz, "gz")
self.cf.addcolumn( np.sqrt( gx * gx +
gy * gy +
gz * gz ),
"modg")
def runtest(self):
g = transform.compute_g_vectors(self.tth,
self.eta,
self.omega,
self.wvln,
wedge=self.w,
chi=self.c)
tth, eta, omega = transform.uncompute_g_vectors(g,
self.wvln,
wedge=self.w,
chi=self.c)
# print tth
# print eta
# print omega
print "# w c i tth tth etao etaC omegao omegaC etaC2 omegaC2"
for i in range(len(tth)):
print self.w, self.c, i,
best = np.argmin(
np.abs(angmod(np.array(omega)[:, i] - self.omega[i])))
deta = angmod(np.array(eta)[best, i] - self.eta[i])
domega = angmod(np.array(omega)[best, i] - self.omega[i])
print ("%8.2f "*8)%(self.tth[i], tth[i],self.eta[i], eta[best][i],\
self.omega[i], omega[best][i],eta[1-best][i],omega[1-best][i])
self.assertAlmostEqual(self.tth[i], tth[i], 5)
self.assertAlmostEqual(deta, 0.0, 5)
self.assertAlmostEqual(domega, 0.0, 5)
def get_peak_quantities(self, flt, pars, OMSLOP, origin=[0, 0, 0]):
"""
Compute twotheta, eta, g-vector for given origin = [x, y]
obs: Computes for all peaks generated from all grains.
If no origin specified origin is set to [0,0,0]
"""
pars.parameters['t_x'] = np.ones(flt.nrows) * origin[0]
pars.parameters['t_y'] = np.ones(flt.nrows) * origin[1]
pars.parameters['t_z'] = np.zeros(flt.nrows)
tth, eta = scanning_transform.compute_tth_eta([flt.sc, flt.fc],
omega=flt.omega,
**pars.parameters)
gve = transform.compute_g_vectors(tth,
eta,
flt.omega,
pars.get('wavelength'),
wedge=pars.get('wedge'),
chi=pars.get('chi'))
pars.parameters['t_x'] = 0
pars.parameters['t_y'] = 0
pars.parameters['t_z'] = 0
return tth, eta, gve
def find_vol(self, border, omegarange):
"""
find limiting volume
The four image corners over 360 degrees
np is the number of pixels per hkl
returns (RSV, NR)
RSV min/max in reciprocal space (np*ubi).gv
NR number of points == 1+RSV[i][1]-RSV[i][0]
"""
# Note that ImageD11 peaks are [slow, fast]
# 1 2 3
# 4 5 6
# 7 8 9
p1 = [
-border, self.dims[0] / 2, self.dims[0] + border, self.dims[0] / 2,
self.dims[0] + border, -border, self.dims[0] + border, -border,
self.dims[0] / 2
]
p2 = [
-border, self.dims[1] / 2, self.dims[1] + border, -border,
self.dims[1] / 2, self.dims[1] + border, -border, self.dims[1] / 2,
self.dims[1] + border
]
for i in range(9):
p1[i], p2[i] = self.spatial.correct(p1[i], p2[i])
peaks = [p1 * len(omegarange), p2 * len(omegarange)]
om = numpy.array(list(omegarange) * 9, numpy.float32)
tth, eta = transform.compute_tth_eta(peaks,
**self.pars.get_parameters())
#print "tth",tth.min(),tth.max()
#print "eta",eta.min(),eta.max()
assert om.shape == tth.shape
gv = transform.compute_g_vectors(tth, eta, om,
self.pars.get('wavelength'),
float(self.pars.get('wedge')),
float(self.pars.get('chi')))
# Rotate g-vectors into target volume
hkls = numpy.dot(self.uspace, gv)
# print "Ranges for RSV"
bounds = numpy.zeros((3, 2))
npv = numpy.zeros(3)
for i in range(3):
bounds[i][0] = numpy.floor(hkls[i].min())
bounds[i][1] = numpy.ceil(hkls[i].max())
npv[i] = (bounds[i][1] - bounds[i][0]) + 1
self.bounds = bounds
self.rsv = rsv.rsv(npv, bounds=bounds, np=self.np)
# Cross your fingers and....
self.rsv.allocate_vol()
def readimage(self, image):
from ImageD11 import transform
from fabio import openimage
self.imageobj = openimage.openimage(image)
# map from 2048x2048 to 1024x1024
d = self.imageobj.data.astype(numpy.float32)
mi = d.mean() - d.std() * 2
mx = d.mean() * d.std() * 2
shape = self.imageobj.data.shape
d = numpy.reshape(numpy.clip(self.imageobj.data, mi, mx),
shape) # makes a clipped copy
d = (255. * (d - mi) / (mx - mi)) # scale intensity
print d.min(), d.max(), d.mean()
self.image = numpy.zeros((1024, 1024), numpy.uint8)
if d.shape == (2048, 2048):
# rebin 2x2
im = (d[::2, ::2] + d[::2, 1::2] + d[1::2, ::2] +
d[1::2, 1::2]) / 4
self.image = (255 - im).astype(numpy.uint8).tostring()
self.imageWidth = 1024
self.imageHeight = 1024
# make a 2D array of x,y
p = []
pk = []
step = 64
r = [[0, 0], [0, step], [step, step], [step, 0]]
for i in range(0, 1024, step):
for j in range(0, 1024, step):
# i,j 1024x1024 texture coords
# x,y spatially corrected
for v in r:
pk.append([i + v[0], j + v[1]])
x, y = self.corrector.correct((i + v[0]) * 2,
(j + v[1]) * 2) # corrected
p.append([x, y])
p = numpy.array(p).T
pk = numpy.array(pk).T
omega = float(self.imageobj.header['Omega'])
self.pars['distance'] = float(self.pars['distance']) * 1000
tth, eta = transform.compute_tth_eta(p, **self.pars)
gve = transform.compute_g_vectors(tth, eta,
omega * self.pars['omegasign'],
self.pars['wavelength'])
self.pts = []
print "Setting up image mapping", p.shape, gve.shape
for i in range(pk.shape[1]):
self.pts.append([
pk[1, i] / 1024., pk[0, i] / 1024., gve[0, i], gve[1, i],
gve[2, i]
])
#for p in self.pts:
# print p
self.setupTexture()
def computegv(self):
sign = float(self.pars.get('omegasign'))
tx = float(self.pars.get('t_x'))
ty = float(self.pars.get('t_y'))
tz = float(self.pars.get('t_z'))
wvln= float(self.pars.get('wavelength'))
start = time.clock()
self.gv = XSXB_to_gv( self.XS, self.XB, tx, ty, tz, wvln)
#print "time for gv only",time.clock()-start
#start = time.clock()
ret = d_XSXB_to_gv( self.XS, self.XB, tx, ty, tz, wvln)
#print "time for derivs too",time.clock()-start
self.deriv_g_t = ret[1:]
if 0:
tth, eta = transform.compute_tth_eta_from_xyz(
self.peaks_xyz, self.colfile.omega*sign,
**self.pars.parameters)
gvtest = transform.compute_g_vectors( tth, eta, self.colfile.omega*sign,
float(self.pars.get('wavelength')),
float(self.pars.get('wedge')),
float(self.pars.get('chi')))
assert (abs(self.gv - gvtest)).max() < 1e-12, "gvector error"
ret = d_XSXB_to_gv( self.XS, self.XB, tx, ty, tz, wvln)
g = ret[0]
dg0_dt = ret[1],ret[4],ret[7]
dg1_dt = ret[2],ret[5],ret[8]
dg2_dt = ret[3],ret[6],ret[9]
assert (abs(g - gvtest)).max() < 1e-12, "gvector deriv error"
delta = 1.0
dgtx = XSXB_to_gv( self.XS, self.XB, tx+delta, ty, tz, wvln)-self.gv
dgty = XSXB_to_gv( self.XS, self.XB, tx, ty+delta, tz, wvln)-self.gv
dgtz = XSXB_to_gv( self.XS, self.XB, tx, ty, tz+delta, wvln)-self.gv
def pe(a,b):
return abs(a-b)/abs(a+b)
print(abs((dg0_dt[0] - dgtx[0])).max())
print(abs((dg0_dt[1] - dgty[0])).max())
print(abs((dg0_dt[2] - dgtz[0])).max())
print(abs((dg1_dt[0] - dgtx[1])).max())
print(abs((dg1_dt[1] - dgty[1])).max())
print(abs((dg1_dt[2] - dgtz[1])).max())
print(abs((dg2_dt[0] - dgtx[2])).max())
print(abs((dg2_dt[1] - dgty[2])).max())
print(abs((dg2_dt[2] - dgtz[2])).max())
self.ds = np.sqrt( (self.gv*self.gv).sum(axis=0) )
self.colfile.addcolumn( self.gv[0], 'gx')
self.colfile.addcolumn( self.gv[1], 'gy')
self.colfile.addcolumn( self.gv[2], 'gz')
self.colfile.addcolumn( self.ds, 'ds')
def calccolumns(p, c, g, pks=None):
"""
p = parameters
c = columnfile
g = grain
pks = selection of which peaks to use for the grain. If none we do all.
"""
t = g.translation
p.set('t_x', t[0])
p.set('t_y', t[1])
p.set('t_z', t[2])
# tth, eta of the spots given this origin position
if pks is None:
pks = ~np.isnan(c.sc)
tth, eta = transform.compute_tth_eta([c.sc[pks], c.fc[pks]],
omega=c.omega[pks],
**p.parameters)
# g-vectors given this origin
gve = transform.compute_g_vectors(tth, eta, c.omega[pks],
p.get("wavelength"), p.get("wedge"),
p.get("chi"))
# Find hkl indices
hklo = np.dot(g.ubi, gve)
hkli = np.round(hklo)
diff = hklo - hkli
# Now uncompute to get ideal spot positions in each case:
gcalc = np.dot(g.ub, hkli)
tthcalc, etacalc, omegacalc = transform.uncompute_g_vectors(
gcalc, p.get("wavelength"), p.get("wedge"), p.get("chi"))
# which eta to choose - there are two possibilities
# ... eta should always be in -180, 180 as it is arctan2
smatch = np.sign(eta) == np.sign(etacalc[0])
etachosen = np.where(smatch, etacalc[0], etacalc[1])
omegachosen = np.where(smatch, omegacalc[0], omegacalc[1])
# deal with the mod360 for omega
omegachosen = mod360(omegachosen, c.omega[pks])
fcc, scc = transform.compute_xyz_from_tth_eta(tthcalc, etachosen,
omegachosen, **p.parameters)
# how close to reciprocal lattice point (could throw out some peaks here...)
drlv = np.sqrt((diff * diff).sum(axis=0))
# save arrays to colfile:
c.drlv[pks] = drlv
c.tth_per_grain[pks] = tth
c.eta_per_grain[pks] = eta
c.tthcalc[pks] = tthcalc
c.etacalc[pks] = etachosen
c.omegacalc[pks] = omegachosen
c.sccalc[pks] = scc
c.fccalc[pks] = fcc
return c
def gridgrains(
ul,
flt,
pars,
minx=-750,
maxx=750,
stepx=25,
miny=-750,
maxy=750,
stepy=25,
tol=0.05,
):
trn = transformer.transformer()
trn.loadfiltered(flt)
trn.parameterobj = parameters.parameters(**pars)
peaks = [trn.getcolumn(trn.xname), trn.getcolumn(trn.yname)]
peaks_xyz = transform.compute_xyz_lab(peaks,
**trn.parameterobj.get_parameters())
omega = trn.getcolumn(trn.omeganame)
trn.updateparameters()
tx = minx - stepx
n = 0
sys.stderr.write("Using tol = %f\n" % (tol))
while tx <= maxx:
tx = tx + stepx
ty = miny - stepy
while ty <= maxy:
ty = ty + stepy
trn.parameterobj.set_parameters({'t_x': tx, 't_y': ty})
pars = trn.parameterobj.get_parameters()
tth, eta = transform.compute_tth_eta_from_xyz(
peaks_xyz, omega, **pars)
if 'omegasign' in pars:
om_sgn = float(pars["omegasign"])
else:
om_sgn = 1.0
gv = transform.compute_g_vectors(tth, eta, omega * om_sgn, **pars)
print(tx, ty, end=' ')
for ubi in ul:
ns = score(ubi, gv.T, tol)
print(ns, end=' ')
n += ns
print()
return n
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 updateGeometry(self, pars=None):
"""
changing or not the parameters it (re)-computes:
xl,yl,zl = ImageD11.transform.compute_xyz_lab
tth, eta = ImageD11.transform.compute_tth_eta
gx,gy,gz = ImageD11.transform.compute_g_vectors
"""
if pars is not None:
self.setparameters(pars)
pars = self.parameters
if "sc" in self.titles and "fc" in self.titles:
pks = self.sc, self.fc
elif "xc" in self.titles and "yc" in self.titles:
pks = self.xc, self.yc
else:
raise Exception("columnfile file misses xc/yc or sc/fc")
xl, yl, zl = transform.compute_xyz_lab(pks, **pars.parameters)
peaks_xyz = np.array((xl, yl, zl))
assert "omega" in self.titles, "No omega column"
om = self.omega * float(pars.get("omegasign"))
tth, eta = transform.compute_tth_eta_from_xyz(peaks_xyz, om,
**pars.parameters)
gx, gy, gz = transform.compute_g_vectors(tth,
eta,
om,
wvln=pars.get("wavelength"),
wedge=pars.get("wedge"),
chi=pars.get("chi"))
modg = np.sqrt(gx * gx + gy * gy + gz * gz)
self.addcolumn(xl, "xl")
self.addcolumn(yl, "yl")
self.addcolumn(zl, "zl")
self.addcolumn(
tth,
"tth",
)
self.addcolumn(
eta,
"eta",
)
self.addcolumn(gx, "gx")
self.addcolumn(gy, "gy")
self.addcolumn(gz, "gz")
self.addcolumn(modg, "ds") # dstar
def testhklcalc_many(wedge, chi):
# hklcalc_many
# apply wedge, chi to axis if necessary
axis = np.array( [0,0,-1], np.float )
UBI = np.eye(3).ravel()
hkl = np.zeros( (len(omega), 3), np.float)
XL = np.ones( (len(omega), 3), np.float)*1e3
T = np.array([100,200,300],np.float)
wvln = 0.254
pre = np.eye(3).ravel()
post = gv_general.chiwedge( wedge=wedge, chi=chi ).ravel()
kc = XL.copy()
wripaca.hklcalc_many( XL, axis, omega*np.pi/180, UBI, T, pre, post, hkl, wvln, kc)
print "axis is",axis
t, e = transform.compute_tth_eta_from_xyz( XL.T,
t_x = T[0],
t_y = T[1],
t_z = T[2],
omega = omega,
wedge = wedge,
chi = chi
)
#print t,e,omega
ori = transform.compute_grain_origins( omega, wedge=wedge, chi=chi,
t_x = T[0], t_y = T[1], t_z = T[2] )
print "last origin",ori.T[-1],ori.T[0]
print "last xl",XL[-1],XL[0]
kve = transform.compute_k_vectors( t, e, wvln )
print "last k",kve.T[-1],kve.T[0]
gve = transform.compute_g_vectors( t, e, omega, wvln, wedge=wedge, chi=chi )
print "last g",gve.T[-1],gve.T[0]
htest = np.dot( UBI.reshape(3,3), gve )
for i in range(len(t)):
# print gve[:,i]
# print hkl[i]
if ((gve[:,i]-hkl[i])**2).sum() > 1e-10:
print "FAIL",
print i,gve[:,i],hkl[i],((gve[:,i]-hkl[i])**2).sum()
print wedge,chi
sys.exit()
print "OK for wedge",wedge,"chi",chi
def update_cols_per_grain(self, flt, pars, OMSLOP, grains, x, y):
"""
update the twotheta, eta, g-vector columns to be sure they are right
fill in some weighting estimates for fitting
"""
# Fill flt columns by iterating over the grains
for i, gr in enumerate(grains):
peak_pos = [flt.sc[gr.mask], flt.fc[gr.mask]]
omega = flt.omega[gr.mask]
pars.parameters['t_x'] = np.ones(np.sum(
gr.mask)) * x[i] #origin[0]
pars.parameters['t_y'] = np.ones(np.sum(
gr.mask)) * y[i] #0 #origin[1]
pars.parameters['t_z'] = np.zeros(np.sum(gr.mask))
tth, eta = scanning_transform.compute_tth_eta(peak_pos,
omega=omega,
**pars.parameters)
gve = transform.compute_g_vectors(tth,
eta,
omega,
pars.get('wavelength'),
wedge=pars.get('wedge'),
chi=pars.get('chi'))
pars.parameters['t_x'] = 0
pars.parameters['t_y'] = 0
pars.parameters['t_z'] = 0
flt.tth[gr.mask] = tth
flt.eta[gr.mask] = eta
if flt.wtth.any():
# Compute the relative tth, eta, omega errors ...
wtth, weta, womega = self.grain_fitter.estimate_weights(
pars, flt, OMSLOP, gr)
flt.wtth[gr.mask] = wtth
flt.weta[gr.mask] = weta
flt.womega[gr.mask] = womega
flt.gx[gr.mask] = gve[0]
flt.gy[gr.mask] = gve[1]
flt.gz[gr.mask] = gve[2]
return flt.tth, flt.eta, np.array([flt.gx, flt.gy, flt.gz])
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 update_cols( flt, pars, OMSLOP ):
"""
update the twotheta, eta, g-vector columns to be sure they are right
fill in some weighting estimates for fitting
"""
tth, eta = transform.compute_tth_eta( [flt.sc, flt.fc], **pars.parameters )
gve = transform.compute_g_vectors( tth, eta, flt.omega,
pars.get('wavelength'),
wedge=pars.get('wedge'),
chi=pars.get('chi') )
flt.addcolumn( tth , "tth" )
flt.addcolumn( eta , "eta" )
# Compute the relative tth, eta, omega errors ...
wtth, weta, womega = estimate_weights( pars, flt, OMSLOP )
flt.addcolumn( wtth, "wtth" )
flt.addcolumn( weta, "weta" )
flt.addcolumn( womega, "womega" )
flt.addcolumn( gve[0], "gx" )
flt.addcolumn( gve[1], "gy" )
flt.addcolumn( gve[2], "gz" )
return tth, eta, gve
def computegv(self):
"""
Using tth, eta and omega angles, compute x,y,z of spot
in reciprocal space
"""
if "tth" not in self.colfile.titles:
self.compute_tth_eta()
pars = self.parameterobj.get_parameters()
if "omegasign" in pars:
om_sgn = pars["omegasign"]
else:
om_sgn = 1.0
gv = transform.compute_g_vectors(self.getcolumn("tth"),
self.getcolumn("eta"),
self.getcolumn("omega") * om_sgn,
self.parameterobj.get('wavelength'),
wedge=self.parameterobj.get('wedge'),
chi=self.parameterobj.get('chi'))
self.addcolumn(gv[0], "gx")
self.addcolumn(gv[1], "gy")
self.addcolumn(gv[2], "gz")
def fitpair(cf, pair, pars, sol0=None):
# pair is a pair of peaks with g, -g
i, j = pair
if sol0 is None:
tx0 = 0.
ty0 = 0.
tz0 = 0.
t0 = np.zeros(3)
else:
tx0, ty0, tz0 = sol0
t0 = sol0
xyz = np.array(
((cf.xl[i], cf.yl[i], cf.zl[i]), (cf.xl[j], cf.yl[j], cf.zl[j]))).T
om = np.array((cf.omega[i], cf.omega[j]))
tth0, eta0 = transform.compute_tth_eta_from_xyz(xyz,
om,
t_x=tx0,
t_y=ty0,
t_z=tz0,
wedge=pars.get('wedge'),
chi=pars.get('chi'))
g0 = transform.compute_g_vectors(tth0,
eta0,
om,
pars.get("wavelength"),
wedge=pars.get('wedge'),
chi=pars.get('chi'))
tth1, eta1 = transform.compute_tth_eta_from_xyz(xyz,
om,
t_x=tx0 + 1,
t_y=ty0,
t_z=tz0,
wedge=pars.get('wedge'),
chi=pars.get('chi'))
g1 = transform.compute_g_vectors(tth1,
eta1,
om,
pars.get("wavelength"),
wedge=pars.get('wedge'),
chi=pars.get('chi'))
dg_dtx = g1 - g0
tth1, eta1 = transform.compute_tth_eta_from_xyz(xyz,
om,
t_x=tx0,
t_y=ty0 + 1,
t_z=tz0,
wedge=pars.get('wedge'),
chi=pars.get('chi'))
g1 = transform.compute_g_vectors(tth1,
eta1,
om,
pars.get("wavelength"),
wedge=pars.get('wedge'),
chi=pars.get('chi'))
dg_dty = g1 - g0
tth1, eta1 = transform.compute_tth_eta_from_xyz(xyz,
om,
t_x=tx0,
t_y=ty0,
t_z=tz0 + 1,
wedge=pars.get('wedge'),
chi=pars.get('chi'))
g1 = transform.compute_g_vectors(tth1,
eta1,
om,
pars.get("wavelength"),
wedge=pars.get('wedge'),
chi=pars.get('chi'))
dg_dtz = g1 - g0
# kx = kx , ky = -ky , kz = -kz
gerr = g0[:, 0] + g0[:, 1]
de_dtx = dg_dtx[:, 0] + dg_dtx[:, 1]
de_dty = dg_dty[:, 0] + dg_dty[:, 1]
de_dtz = dg_dtz[:, 0] + dg_dtz[:, 1]
grad = (de_dtx, de_dty, de_dtz)
rhs = np.zeros(3)
mat = np.zeros((3, 3))
if 0 and sol0 is not None:
print(tth0)
print(eta0)
print(g0)
print(gerr)
for i in range(3):
rhs[i] = np.dot(grad[i], gerr)
for j in range(i, 3):
mat[i, j] = mat[j, i] = np.dot(grad[i], grad[j])
w, v = np.linalg.eigh(mat)
### mat = v.T . w . v.T-1
### mat = v.T . w . v since v is like a U matrix (orthonormal)
### mat-1 = v.T . 1/w . v
ww = np.eye(3)
ans = np.zeros(3)
sol = t0
# Take the two largest eigenvalues, eigh says sorted
assert w[0] < w[1] < w[2], "check eigh returns sorted?"
for i in range(2, 0, -1):
ww[i, i] = 1 / w[i]
ans += np.dot(v, ww[i] * np.dot(v.T, rhs))
sol -= ans / w[i]
print(i, ans, sol, w[i])
ans = -unit(np.dot(v, ww[2] * np.dot(v.T, rhs)))
sol -= ans * w[2]
print(ans, sol, w)
imat = np.dot(np.dot(v, ww), v.T)
#print('ima',np.dot(np.linalg.inv( mat ) , rhs ))
return sol, ans, (w[0] / w[1], w[1] / w[2])
assert ((cv-rv)**2).sum()<1e-10,"badness in axis angle"
print "AxisAngleOK"
testaxisang()
def anglediff(a1, a2):
return np.arctan2(np.sin(a1-a2), np.cos(a1-a2))
for wedge, chi in [(0.,0.),(-10.,0.), (11,-15), (0,6)]:
print "Wedge",wedge,"chi",chi
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
try:
pks = [c.sc, c.fc]
except:
pks = [c.xc, c.yc]
wvln = float(p.get("wavelength"))
wedge = float(p.get("wedge"))
chi = float(p.get("chi"))
t = np.array([float(p.get("t_x")),
float(p.get("t_y")),
float(p.get("t_z"))], np.float32)
print("Reading %.4f" % (time.time() - start), end=' ')
start = time.time()
for i in range(10):
xlylzl = compute_xyz_lab(pks, **p.parameters)
tth, eta = compute_tth_eta_from_xyz(xlylzl, c.omega, **p.parameters)
gv = compute_g_vectors(tth, eta, c.omega * p.get('omegasign'), wvln, wedge,
chi)
d1 = time.time() - start
osi = p.get('omegasign')
gvf = np.zeros(xlylzl.shape, np.float, order='F')
start = time.time()
for i in range(100):
fImageD11.compute_gv(xlylzl, c.omega, osi, wvln, wedge, chi, t, gvf)
d2 = time.time() - start
print("%.4f %.4f" % (d1, d2), "Ratio %.2f" % (10 * d1 / d2))
err = gv - gvf
scor = abs(err).mean(axis=1) / abs(gv).mean(axis=1)
assert (scor < 1e-6).all(), "Mismatch"
def compute_gv(self, thisgrain, update_columns=False):
"""
Makes self.gv refer be g-vectors computed for this grain in this scan
"""
peaks_xyz = thisgrain.peaks_xyz
om = thisgrain.om
try:
sign = self.parameterobj.parameters['omegasign']
except:
sign = 1.0
# translation should match grain translation here...
self.tth, self.eta = transform.compute_tth_eta_from_xyz(
peaks_xyz.T, omega=om * sign, **self.parameterobj.parameters)
gv = transform.compute_g_vectors(
self.tth, self.eta, om * sign,
float(self.parameterobj.parameters['wavelength']),
self.parameterobj.parameters['wedge'],
self.parameterobj.parameters['chi'])
if self.OMEGA_FLOAT:
mat = thisgrain.ubi.copy()
gvT = numpy.ascontiguousarray(gv.T)
junk = cImageD11.score_and_refine(mat, gvT, self.tolerance)
hklf = numpy.dot(mat, gv)
hkli = numpy.round(hklf)
gcalc = numpy.dot(numpy.linalg.inv(mat), hkli)
tth, [eta1,
eta2], [omega1, omega2] = transform.uncompute_g_vectors(
gcalc, float(self.parameterobj.parameters['wavelength']),
self.parameterobj.parameters['wedge'],
self.parameterobj.parameters['chi'])
e1e = numpy.abs(eta1 - self.eta)
e2e = numpy.abs(eta2 - self.eta)
try:
eta_err = numpy.array([e1e, e2e])
except:
print(e1e.shape, e2e.shape, e1e)
raise
best_fitting = numpy.argmin(eta_err, axis=0)
# These are always 1 or zero
# pick the right omega (confuddled by take here)
omega_calc = best_fitting * omega2 + (1 - best_fitting) * omega1
# Take a weighted average within the omega error of the observed
omerr = (om * sign - omega_calc)
# Clip to 360 degree range
omerr = omerr - (360 * numpy.round(omerr / 360.0))
# print omerr[0:5]
omega_calc = om * sign - numpy.clip(omerr, -self.slop, self.slop)
# print omega_calc[0], om[0]
thisgrain.omega_calc = omega_calc
# Now recompute with improved omegas... (tth, eta do not change much)
#self.tth, self.eta = transform.compute_tth_eta(
# numpy.array([x, y]),
# omega = omega_calc,
# **self.parameterobj.parameters)
self.tth, self.eta = transform.compute_tth_eta_from_xyz(
peaks_xyz.T, omega=om * sign, **self.parameterobj.parameters)
gv = transform.compute_g_vectors(
self.tth, self.eta, omega_calc,
float(self.parameterobj.parameters['wavelength']),
self.parameterobj.parameters['wedge'],
self.parameterobj.parameters['chi'])
else:
thisgrain.omega_calc[:] = 0
# update tth_per_grain and eta_per_grain
if update_columns:
name = thisgrain.name.split(":")[1]
numpy.put(self.scandata[name].tth_per_grain, thisgrain.ind,
self.tth)
numpy.put(self.scandata[name].eta_per_grain, thisgrain.ind,
self.eta)
if self.OMEGA_FLOAT:
numpy.put(self.scandata[name].omegacalc_per_grain,
thisgrain.ind, omega_calc)
self.gv = numpy.ascontiguousarray(gv.T)
return
