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 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 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 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 compute_tth_eta(self):
""" Compute the twotheta and eta for peaks previous read in """
if None in [self.xname, self.yname]:
raise Exception("No peaks loaded")
peaks = [self.getcolumn(self.xname), self.getcolumn(self.yname)]
peaks_xyz = transform.compute_xyz_lab(
peaks, **self.parameterobj.get_parameters())
# Store these in the columnfile
self.addcolumn(peaks_xyz[0], "xl")
self.addcolumn(peaks_xyz[1], "yl")
self.addcolumn(peaks_xyz[2], "zl")
# Get the Omega name?
omega = self.getcolumn(self.omeganame)
tth, eta = transform.compute_tth_eta_from_xyz(
peaks_xyz, omega, **self.parameterobj.get_parameters())
self.addcolumn(tth, "tth")
self.addcolumn(eta, "eta")
return tth, eta
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 test1():
np.random.seed(42)
w = 40 / 12.
nv = 1024 * 1024
xyz = 1e5 * (np.random.random((nv, 3)) + (0.2, -0.5, -0.5)).T
old = []
new = []
for i in range(5):
start = timer()
t, e = compute_tth_eta_from_xyz(xyz, None)
k = compute_k_vectors(t, e, w)
old.append(timer() - start)
knew = k_from_xyz(xyz, w)
start = timer()
ok = np.allclose(k, knew)
new.append(timer() - start)
if ok:
print("Matches", nv)
else:
print("Fails")
print("old perf", np.min(old), np.mean(old), np.std(old))
print("new perf", np.min(new), np.mean(new), np.std(new))
print("speedup", np.min(old) / np.min(new))
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])
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 assignlabels(self, quiet=False):
"""
Fill out the appropriate labels for the spots
"""
if not quiet:
print("Assigning labels with XLYLZL")
import time
start = time.time()
for s in self.scannames:
self.scandata[s].labels = self.scandata[s].labels * 0 - 2 # == -1
drlv2 = numpy.zeros(len(self.scandata[s].drlv2), numpy.float) + 1
nr = self.scandata[s].nrows
sc = self.scandata[s].sc
fc = self.scandata[s].fc
om = self.scandata[s].omega
# Looks like this in one dataset only
ng = len(self.grainnames)
int_tmp = numpy.zeros(nr, numpy.int32) - 1
tmp = transform.compute_xyz_lab(
[self.scandata[s].sc, self.scandata[s].fc],
**self.parameterobj.parameters)
peaks_xyz = tmp.T.copy()
if not quiet:
print("Start first grain loop", time.time() - start)
start = time.time()
gv = numpy.zeros((nr, 3), numpy.float)
wedge = self.parameterobj.parameters['wedge']
omegasign = self.parameterobj.parameters['omegasign']
chi = self.parameterobj.parameters['chi']
wvln = self.parameterobj.parameters['wavelength']
first_loop = time.time()
drlv2 = (self.scandata[s].drlv2 * 0 + 1).astype(float) # == 1
int_tmp = numpy.zeros(nr, numpy.int32) - 1
for ig, g in enumerate(self.grainnames):
gr = self.grains[(g, s)]
self.set_translation(g, s)
cImageD11.compute_gv(peaks_xyz, self.scandata[s].omega,
omegasign, wvln, wedge, chi,
gr.translation, gv)
cImageD11.score_and_assign(gr.ubi, gv, self.tolerance, drlv2,
int_tmp, int(g))
if not quiet:
print(time.time() - first_loop, "First loop")
self.gv = gv.copy()
# Second loop after checking all grains
if not quiet:
print("End first grain loop", time.time() - start)
start = time.time()
if not quiet:
print(self.scandata[s].labels.shape, \
numpy.minimum.reduce(self.scandata[s].labels),\
numpy.maximum.reduce(self.scandata[s].labels))
self.scandata[s].addcolumn(int_tmp, "labels")
self.scandata[s].addcolumn(drlv2, "drlv2")
if not quiet:
print(self.scandata[s].labels.shape, \
numpy.minimum.reduce(self.scandata[s].labels),\
numpy.maximum.reduce(self.scandata[s].labels))
tth = numpy.zeros(nr, numpy.float32) - 1
eta = numpy.zeros(nr, numpy.float32)
self.scandata[s].addcolumn(tth, "tth_per_grain")
self.scandata[s].addcolumn(eta, "eta_per_grain")
self.scandata[s].addcolumn(om * 0, "omegacalc_per_grain")
self.scandata[s].addcolumn(self.gv[:, 0], "gx")
self.scandata[s].addcolumn(self.gv[:, 1], "gy")
self.scandata[s].addcolumn(self.gv[:, 2], "gz")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "hr")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "kr")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "lr")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "h")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "k")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "l")
if not quiet:
print("Start second grain loop", time.time() - start)
start = time.time()
# We have the labels set in self.scandata!!!
for g in self.grainnames:
gr = self.grains[(g, s)]
ind = numpy.compress(int_tmp == g, numpy.arange(nr))
#print 'x',gr.x[:10]
#print 'ind',ind[:10]
gr.ind = ind # use this to push back h,k,l later
gr.peaks_xyz = numpy.take(peaks_xyz, ind, axis=0)
gr.sc = numpy.take(sc, ind)
gr.fc = numpy.take(fc, ind)
gr.om = numpy.take(self.scandata[s].omega, ind)
gr.omega_calc = gr.om.copy()
gr.npks = len(gr.ind)
self.set_translation(g, s)
try:
sign = self.parameterobj.parameters['omegasign']
except:
sign = 1.0
tth, eta = transform.compute_tth_eta_from_xyz(
gr.peaks_xyz.T,
omega=gr.om * sign,
**self.parameterobj.parameters)
self.scandata[s].tth_per_grain[ind] = tth
self.scandata[s].eta_per_grain[ind] = eta
# self.scandata[s].omegacalc_per_grain[ind] = gr.omega_calc
self.grains[(g, s)] = gr
if not quiet:
print("Grain", g, "Scan", s, "npks=", len(ind))
#print 'x',gr.x[:10]
# Compute the total integrated intensity if we have enough
# information available
compute_lp_factor(self.scandata[s])
for g in self.grainnames:
gr = self.grains[(g, s)]
gr.intensity_info = compute_total_intensity(
self.scandata[s],
gr.ind,
self.intensity_tth_range,
quiet=quiet)
if not quiet:
print("End second grain loop", time.time() - start)
print()
start = time.time()
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
def assignlabels(self, quiet=False):
"""
Fill out the appropriate labels for the spots
"""
if not quiet:
print "Assigning labels with XLYLZL"
import time
start = time.time()
for s in self.scannames:
self.scandata[s].labels = self.scandata[s].labels * 0 - 2 # == -1
drlv2 = numpy.zeros(len(self.scandata[s].drlv2), numpy.float) + 1
nr = self.scandata[s].nrows
sc = self.scandata[s].sc
fc = self.scandata[s].fc
# Looks like this in one dataset only
ng = len(self.grainnames)
int_tmp = numpy.zeros(nr, numpy.int32) - 1
if 0: # this is pretty slow
tth_tmp = numpy.zeros((ng, nr), numpy.float32) - 1
eta_tmp = numpy.zeros((ng, nr), numpy.float32)
peaks_xyz = transform.compute_xyz_lab(
[self.scandata[s].sc, self.scandata[s].fc],
**self.parameterobj.parameters)
if not quiet:
print "Start first grain loop", time.time() - start
start = time.time()
gv = numpy.zeros(peaks_xyz.shape, numpy.float, order='F')
wedge = self.parameterobj.parameters['wedge']
omegasign = self.parameterobj.parameters['omegasign']
chi = self.parameterobj.parameters['chi']
wvln = self.parameterobj.parameters['wavelength']
first_loop = time.time()
import fImageD11
drlv2_2 = self.scandata[s].drlv2 * 0 + 1 # == 1
int_tmp_2 = numpy.zeros(nr, numpy.int32) - 1
for g, ig in zip(self.grainnames, range(ng)):
assert g == ig, "sorry - a bug in program"
gr = self.grains[(g, s)]
self.set_translation(g, s)
gr.peaks_xyz = peaks_xyz
gr.om = self.scandata[s].omega
# self.compute_gv( gr )
# print peaks_xyz.shape, self.scandata[s].omega.shape, gv.shape
fImageD11.compute_gv(peaks_xyz, self.scandata[s].omega,
omegasign, wvln, wedge, chi,
gr.translation, gv)
fImageD11.assign(gr.ubi, gv, self.tolerance, drlv2, int_tmp,
int(g))
# closest.score_and_assign( gr.ubi,
# gv.T,
# self.tolerance,
# drlv2_2,
# int_tmp_2,
# int(g))
if not quiet:
print time.time() - first_loop, "First loop"
# print "assigned"
self.gv = gv.T.astype(numpy.float32).copy()
# Second loop after checking all grains
if not quiet:
print "End first grain loop", time.time() - start
start = time.time()
if not quiet:
print self.scandata[s].labels.shape, \
numpy.minimum.reduce(self.scandata[s].labels),\
numpy.maximum.reduce(self.scandata[s].labels)
self.scandata[s].addcolumn(int_tmp, "labels")
self.scandata[s].addcolumn(drlv2, "drlv2")
if not quiet:
print self.scandata[s].labels.shape, \
numpy.minimum.reduce(self.scandata[s].labels),\
numpy.maximum.reduce(self.scandata[s].labels)
tth = numpy.zeros(nr, numpy.float32) - 1
eta = numpy.zeros(nr, numpy.float32)
self.scandata[s].addcolumn(tth, "tth_per_grain")
self.scandata[s].addcolumn(eta, "eta_per_grain")
self.scandata[s].addcolumn(self.gv[:, 0], "gx")
self.scandata[s].addcolumn(self.gv[:, 1], "gy")
self.scandata[s].addcolumn(self.gv[:, 2], "gz")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "hr")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "kr")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "lr")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "h")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "k")
self.scandata[s].addcolumn(numpy.zeros(nr, numpy.float32), "l")
if not quiet:
print "Start second grain loop", time.time() - start
start = time.time()
# We have the labels set in self.scandata!!!
for g in self.grainnames:
gr = self.grains[(g, s)]
ind = numpy.compress(int_tmp == g, range(nr))
#print 'x',gr.x[:10]
#print 'ind',ind[:10]
gr.ind = ind # use this to push back h,k,l later
gr.peaks_xyz = numpy.take(peaks_xyz, ind, axis=1)
gr.sc = numpy.take(sc, ind)
gr.fc = numpy.take(fc, ind)
gr.om = numpy.take(self.scandata[s].omega, ind)
gr.npks = len(gr.ind)
self.set_translation(g, s)
try:
sign = self.parameterobj.parameters['omegasign']
except:
sign = 1.0
tth, eta = transform.compute_tth_eta_from_xyz(
gr.peaks_xyz,
omega=gr.om * sign,
**self.parameterobj.parameters)
self.scandata[s].tth_per_grain[ind] = tth
self.scandata[s].eta_per_grain[ind] = eta
self.grains[(g, s)] = gr
if not quiet:
print "Grain", g, "Scan", s, "npks=", len(ind)
#print 'x',gr.x[:10]
# Compute the total integrated intensity if we have enough
# information available
compute_lp_factor(self.scandata[s])
for g in self.grainnames:
gr = self.grains[(g, s)]
gr.intensity_info = compute_total_intensity(
self.scandata[s],
gr.ind,
self.intensity_tth_range,
quiet=quiet)
if not quiet:
print "End second grain loop", time.time() - start
print
start = time.time()
