def main():
colf = columnfile.columnfile(sys.argv[1])
print("Read", colf.nrows, "peaks")
p = parameters.read_par_file(sys.argv[2])
# input a sample radius to use for computing ranges
radius = int(sys.argv[3])
omegastep = guess_omega_step(colf)
print("Guess omega step as", omegastep)
colf.updateGeometry(p)
for i, t in enumerate(colf.titles):
print("\n", t, end=" ")
for j in (0, 1, 2, colf.nrows // 2, colf.nrows // 2 + 1,
colf.nrows // 2 + 2, colf.nrows - 3, colf.nrows - 2,
colf.nrows - 1):
print(colf.bigarray[i, j], end=" ")
print()
modXL = np.sqrt(colf.xl * colf.xl + colf.yl * colf.yl + colf.zl * colf.zl)
modXLmean = modXL.mean()
dangle = np.degrees(np.arctan2(radius, modXLmean))
print("Angle precision is about ", dangle, "for average distance",
modXLmean, "and sample size ", radius)
findpairs_2d(colf, dangle, omegastep)
def main():
import sys, time
c = columnfile(sys.argv[1])
p = read_par_file(sys.argv[2])
u = unitcell_from_parameters(p)
gl = read_grain_file(sys.argv[3])
if gl[0].translation is None:
gl[0].translation = np.array((0., 0., 0.))
start = time.time()
# Setup and assign hkls
w = p.get("wavelength")
peaks_Cxyz, beam_Cxyz = getCxyz(c, p)
t = gl[0].translation.copy()
ub = gl[0].ub.copy()
ubi = gl[0].ubi.copy()
gve = compute_Cgve(t, peaks_Cxyz, beam_Cxyz, w)
hi = np.round(np.dot(ubi, gve))
lastgof = 1e9
ubn, tn = fit_ub_t(ub, t, hi, peaks_Cxyz, beam_Cxyz, w)
print("Before\nt=", gl[0].translation)
print("UB=", gl[0].ub)
gl[0].set_ubi(np.linalg.inv(ubn))
gl[0].translation = tn
dt = time.time() - start
print("time calculating", dt, "gps", 1 / dt)
print("After\nt=", gl[0].translation)
print("UB=", gl[0].ub)
write_grain_file(sys.argv[4], gl)
def test_xyz_from_yaml(self):
for p in parfiles:
parfile = os.path.join(TEST, p)
fltfile = os.path.join(TEST, "test.flt")
ymlfile = os.path.join(
os.path.split(general_geometry.__file__)[0], "data",
"fable.yml")
pars = parameters.read_par_file(parfile).parameters
colf = columnfile.columnfile(fltfile)
sc = colf.sc[:4]
fc = colf.fc[:4]
geometry = general_geometry.from_yml(
pars,
ymlfile,
path=["Positioners", "Fable_detector"],
noisy=False)
# test old
xyz1 = transform.compute_xyz_lab((sc, fc), **pars)
# test new
v = np.zeros((3, len(sc)))
v[1] = fc
v[2] = sc
xyz2 = geometry((np.zeros(len(fc)), fc, sc))
if not np.allclose(xyz1, xyz2):
print("Geometry", geometry)
print("Parfile:", p)
for i in range(len(fc)):
print(xyz1[:, i])
print(xyz2[:, i])
print()
assert np.allclose(xyz1, xyz2)
def __init__(self, fname, parfile):
self.colfile = columnfile(fname)
self.pars = parameters.read_par_file(parfile)
self.ds_tol = 0.005
self.bins = np.arange(0, 0.5, 0.005)
print("Setting up")
self.compute_XLYLZL()
self.computegv()
def __init__(self, fname, parfile):
self.colfile = columnfile( fname )
self.pars = parameters.read_par_file( parfile )
self.ds_tol = 0.005
self.bins=np.arange(0,0.5,0.005)
self.compute_XLYLZL()
self.computegv()
self.makecell()
self.ringassign()
def compute_tth_eta_lut(splinefile, pars, dims):
"""
Computes look up values of tth, eta for each pixel
"""
c = blobcorrector.correctorclass(splinefile)
p = parameters.read_par_file(pars)
xp, yp = c.make_pixel_lut(dims)
t, e = transform.compute_tth_eta((xp.ravel(), yp.ravel()), **p.parameters)
t.shape = dims
e.shape = dims
return t, e
def parseInputFiles(self, gsfile, FLT, par):
self.imageD11Pars = parameters.read_par_file(par)
self.grains = multigrainOutputParser.parse_GrainSpotter_log(gsfile)
print("Parsed grains from %s" % gsfile)
self.ngrains = len(self.grains)
print("Number of grains: %d" % self.ngrains)
[self.peaksflt, self.idlist,
self.header] = multigrainOutputParser.parseFLT(FLT)
print("Parsed peaks from %s" % FLT)
print("Number of peaks: %d" % len(self.peaksflt))
def __init__(self,
param_file,
omegastep,
gradient_constraint,
maxiter=100,
number_cpus=None):
self.params = parameters.read_par_file(param_file)
self.omegastep = omegastep
self.field_converter = FieldConverter()
self.gradient_constraint = gradient_constraint
self.maxiter = maxiter
self.number_cpus = number_cpus
def main2():
import sys
c = columnfile(sys.argv[1])
p = read_par_file(sys.argv[2])
gl = read_grain_file(sys.argv[3])
for i, g in enumerate(gl):
mask = c.labels == i
g.sc = np.compress(mask, c.sc)
g.fc = np.compress(mask, c.fc)
g.omega = np.compress(mask, c.omega)
ubnew, tnew = fitagrain(g, p)
g.set_ubi(np.linalg.inv(ubnew))
g.translation[:] = tnew
print(i, len(g.sc), tnew)
write_grain_file(sys.argv[4], gl)
def main():
flt = columnfile.columnfile( sys.argv[1] )
grains = grain.read_grain_file( sys.argv[2] )
pars = parameters.read_par_file( sys.argv[3] )
newgrainfile = sys.argv[4]
hkltol = 0.05 # for first peak assignments
nmedian = 5 # for removing peak fit outliers
omegastep = 1.0 # for omega images
ymin = 13.5 # dty start (so -15 -> +15 in 0.25 steps)
ystep = 0.02 # step in dty from scan
rcut = 0.2 # cutoff for segmentation of reconstruction
flt.filter( flt.dty >= ymin )
flt.idty = np.round((flt.dty - ymin)/ystep).astype(np.int32) - 35
flt.NY = 71 # flt.idty.max()+1
OMSLOP = omegastep / 2.0
tth, eta, gve = update_cols( flt, pars, OMSLOP )
assign_peaks( grains, gve, flt, pars, nmedian, hkltol )
# pl.ioff()
print("\n\n")
out = open( newgrainfile, "w" )
out.write("# grain ix iy npks ubi00 ubi01 ubi02 ubi10 ubi11 ubi12 ubi20 ubi21 ubi22\n")
for i,g in enumerate(grains):
print("# Grain:",i)
fit_one_grain( g, flt, pars )
y0,x,y = map_out_cell( g, flt )
sinoangles, sino, recon = map_grain( g, flt, ymin, ystep, omegastep )
if 0:
pl.subplot(211)
pl.imshow( sino )
pl.subplot(212)
pl.imshow( recon )
pl.show()
active = recon > recon.max() * rcut
ii, jj = np.mgrid[ 0:recon.shape[0], 0:recon.shape[0] ] - recon.shape[0]//2
for ix, iy in zip(ii[active], jj[active]):
gf = fit_one_point( g, flt, pars, ix, iy, ystep )
r = ("%-4d "*4)%(i,ix,iy,gf.mask.astype(int).sum())
print(r)
u = ("%.7f "*9)%tuple(gf.ubi.ravel())
out.write(r)
out.write(u+"\n")
g.translation = (x,y,0)
def main():
flt = columnfile.columnfile(sys.argv[1])
grains = grain.read_grain_file(sys.argv[2])
pars = parameters.read_par_file(sys.argv[3])
newgrainfile = sys.argv[4]
hkltol = 0.05 # for first peak assignments
nmedian = 5 # for removing peak fit outliers
omegastep = 1.0 # for omega images
ymin = -18 # dty start (so -15 -> +15 in 0.25 steps)
ystep = 0.25 # step in dty from scan
rcut = 0.2 # cutoff for segmentation of reconstruction
OMSLOP = omegastep / 2.0
tth, eta, gve = update_cols(flt, pars, OMSLOP)
assign_peaks(grains, gve, flt, pars, nmedian, hkltol)
pl.ioff()
print("\n\n")
for i, g in enumerate(grains):
print("# Grain:", i)
fit_one_grain(g, flt, pars)
y0, x, y = map_out_cell(g, flt)
sinoangles, sino, recon = map_grain(g, flt, ymin, ystep, omegastep)
if 0:
pl.subplot(211)
pl.imshow(sino)
pl.subplot(212)
pl.imshow(recon)
pl.show()
active = recon > recon.max() * rcut
ii, jj = np.mgrid[0:recon.shape[0],
0:recon.shape[0]] - recon.shape[0] // 2
for ix, iy in zip(ii[active], jj[active]):
gf = fit_one_point(g, flt, pars, ix, iy, ystep)
print(("%-4d " * 4) % (i, ix, iy, gf.mask.astype(int).sum()),
end=" ")
print(("%.6f " * 6) % (indexing.ubitocellpars(gf.ubi)), end=" ")
print(("%.6f " * 3) % tuple(gf.Rod))
g.translation = (x, y, 0)
grain.write_grain_file(newgrainfile, grains)
def test_eu():
from ImageD11.grain import read_grain_file
from ImageD11.columnfile import columnfile
from ImageD11.parameters import read_par_file
gr = read_grain_file("./eu3.map")[0]
par = read_par_file("./0.par")
flt = columnfile( "../demo/eu.flt" )
flt.updateGeometry(par)
gve = np.array( [flt.gx, flt.gy, flt.gz], np.float)
e0,e1,e2 = pkfom( gr, gve )
flt.addcolumn( e0, "e0" )
flt.addcolumn( e1, "e1" )
flt.addcolumn( e2, "e2" )
pl.subplot(131)
pl.scatter( flt.tth, flt.e0, c=flt.eta, edgecolor='none')
pl.subplot(132)
pl.scatter( flt.tth, flt.e1, c=flt.eta, edgecolor='none')
pl.subplot(133)
pl.scatter( flt.tth, flt.e2, c=flt.eta, edgecolor='none')
pl.show()
return gr, flt, par
def test_xyz(self):
for p in parfiles:
parfile = os.path.join(TEST, p)
fltfile = os.path.join(TEST, "test.flt")
pars = parameters.read_par_file(parfile).parameters
colf = columnfile.columnfile(fltfile)
sc = colf.sc
fc = colf.fc
geometry = general_geometry.fable_detector(pars, noisy=False)
# test old
xyz1 = transform.compute_xyz_lab((sc, fc), **pars)
# test new
v = np.zeros((3, len(sc)))
v[1] = fc
v[2] = sc
xyz2 = geometry((np.zeros(len(fc)), fc, sc))
if not np.allclose(xyz1, xyz2):
print("Geometry", geometry)
print("Parfile:", p)
for i in range(len(fc)):
print(xyz1[:, i])
print(xyz2[:, i])
print()
assert np.allclose(xyz1, xyz2)
from __future__ import print_function
from ImageD11 import unitcell, parameters, transform
import numpy as np
import matplotlib.pylab as plt
from mpl_toolkits.mplot3d import Axes3D
import sys
pars = parameters.read_par_file(sys.argv[1])
# Input unit cell from par file
u = unitcell.unitcell_from_parameters(pars)
# Generate diffraction spots for unit cell:
u.makerings(0.7)
hkls = []
for d in u.ringds:
hkls += u.ringhkls[d]
hkls = np.array(hkls).T
# A grain orientation
U0 = transform.detector_rotation_matrix(0.1, 0.2, 0.3)
UB0 = np.dot(U0, u.B)
# Ideal diffraction vectors:
gve = np.dot(UB0, hkls)
modg = np.sqrt((gve * gve).sum(axis=0))
# print scattering vectors in order
order = np.argsort(modg)
for i in order[10::-1]:
from __future__ import print_function
import sys
from ImageD11.columnfile import columnfile
from ImageD11.unitcell import unitcell_from_parameters
from ImageD11.parameters import read_par_file
from ImageD11.transform import compute_tth_eta
import numpy as np
import pylab as pl
# put parfile, npeaks and tol and this would be general purpose!
c = columnfile(sys.argv[1])
p = read_par_file(sys.argv[2])
tol = float(sys.argv[3])
tthmax = float(sys.argv[4])
outfile = sys.argv[5]
npx = int(sys.argv[6])
top = int(sys.argv[7])
c.filter(c.Number_of_pixels > npx)
u = unitcell_from_parameters(p)
w = p.get("wavelength")
tth, eta = compute_tth_eta((c.sc, c.fc), **p.parameters)
dsmax = 2 * np.sin(1.03 * tth.max() * np.pi / 360) / w
u.makerings(dsmax)
mask = np.zeros(c.nrows, dtype=np.bool)
for d in u.ringds:
tthc = np.arcsin(w * d / 2) * 360 / np.pi
grad = np.zeros((len(xk), len(f0)), float)
ei = np.zeros((len(xk), ), float)
for k in range(len(xk)):
ei[k] = 1.0
d = epsilon * ei
grad[k] = (f(*((xk + d, ) + args)) - f0) / d[k]
ei[k] = 0.0
return grad
if __name__ == "__main__":
from ImageD11.columnfile import columnfile
from ImageD11.parameters import read_par_file
import ImageD11.grain
import sys
p = read_par_file(sys.argv[1])
c = columnfile(sys.argv[2])
i = indexer(p, c)
if sys.argv[3][:3] == "fit":
# 0 1 2 3 4 5
# \test\simul_1000_grains>python ..\..\ImageD11\indexer.py Al1000\Al1000.par Al1000\Al1000.flt fit allgrid.map allgridfitscipy.map
gl = ImageD11.grain.read_grain_file(sys.argv[4])
inds = np.arange(len(gl), dtype=np.int)
allhkls = np.array((c.h, c.k, c.l))
for k, g in enumerate(gl):
if len(sys.argv[3]) == len("fit"):
for j, tol in enumerate([0.05, 0.02, 0.01, 0.0075]):
inds, hkls = i.assign(g.ubi, g.translation, tol)
ubi, t = i.refine(g.ubi,
translation=g.translation,
inds=inds,
def __init__(self, param_file):
self.params = parameters.read_par_file(param_file)
self.grain_fitter = GrainFitter()
self.field_converter = FieldConverter()
break
if TESTING:
print("translation", t)
print("Cell", indexing.ubitocellpars(np.linalg.inv(UB)))
print("Translation %.5f %.5f %.5f" % tuple(t))
print("Cell %.7f %.7f %.7f %.8f %.8f %.8f" %
(indexing.ubitocellpars(np.linalg.inv(UB))))
g.translation = t
g.set_ubi(np.linalg.inv(UB))
return grains
# TODO:
#
# DONE : Least squares as SVD problem
# - Allow a constraint matrix to be used
# - Compute weights from experimental data (sig/cov etc)
# DONE (but not weighted or printed) : Compute error estimates
# - Allow fitting of other geometrical parameters
# - Allow refinement in terms of other parameterisation of UB (e.g. U, B)
# - Documentation
if __name__ == "__main__":
colfile, parfile, grainsfile, newgrainsfile = sys.argv[1:5]
c = columnfile.columnfile(colfile)
p = parameters.read_par_file(parfile)
g = grain.read_grain_file(grainsfile)
grain.write_grain_file(newgrainsfile, refit_makemap(c, p, g))
# python teo.py ../test/simul_1000_grains/g187.flt ../test/simul_1000_grains/Al1000/Al1000.par ../test/simul_1000_grains/g187.map teo187fitted.map
def __init__(self, param_file, omegastep, gradient_constraint):
self.params = parameters.read_par_file(param_file)
self.omegastep = omegastep
self.field_converter = FieldConverter()
self.gradient_constraint = gradient_constraint
def __init__(self, param_file, cif_file, omegastep):
self.params = parameters.read_par_file(param_file)
self.cif_file = cif_file
self.omegastep = omegastep
self.field_converter = FieldConverter()
def fitallgrains( gfile, pfile, cfile, ngrains = None):
colfile = loadcolfile( cfile )
grains = read_grain_file( gfile )
pars = read_par_file( pfile )
variables = [ 't_x','t_y', 't_z', 'y_center', 'tilt_y', 'tilt_z',
'tilt_x', 'distance', 'wedge']
pfitted = []
grs = []
cfs = []
if ngrains is None:
ng = len(grains)
else:
ng = ngrains
for i in range(ng):
print "***",i,
gr = grains[i]
cf = assignpeaks( gr, pars, colfile, tol = 0.02 )
cfs.append(cf)
grs.append(gr)
pi = parameters( **pars.parameters )
refpars = fitmanygrains( cfs, grs, pi, variables )
for i in range(3):
refpars = fitmanygrains( cfs, grs, refpars, variables )
if 0:
pi = parameters( **pars.parameters )
pi.set('t_x', gr.translation[0])
pi.set('t_y', gr.translation[1])
pi.set('t_z', gr.translation[2])
diff, Ddiff = fitgrainfunc( cf, gr, pi, variables )
print "%.5g"%((diff*diff).ravel().sum()),
gr, pfit = fitgrain( cf, gr, pi, variables, quiet=True )
grains[i] = gr
pfitted.append( pfit )
diff, Ddiff = fitgrainfunc( cf, gr, pfit, variables )
print "%.5g"%((diff*diff).ravel().sum())
if 0:
v = Ddiff.keys()
for v in ['y_center', 'distance']:
pylab.figure(1)
pylab.title("Versus omega")
pylab.plot( cf.omega, project_diff_on_variable( diff, v, Ddiff) , ",", label=v)
pylab.figure(2)
pylab.title("Versus fc")
pylab.plot( cf.fc, project_diff_on_variable( diff, v, Ddiff) , ",", label=v)
pylab.figure(3)
pylab.title("Versus sc")
pylab.plot( cf.sc, project_diff_on_variable( diff, v, Ddiff) , ",", label=v)
pylab.figure(4)
pylab.title("Versus sigo")
pylab.plot( cf.sigo, project_diff_on_variable( diff, v, Ddiff) , ",", label=v)
pylab.legend()
pylab.show()
raw_input()
write_grain_file( gfile+".fit", grains)
pfit, pcov, info, errmsg, ier = res
if ier not in [1,2,3,4]:
print s_sq, ier, errmsg
else:
residu = f(pfit)
s_sq = (residu**2).sum()/(len(residu)-len(p0))
ubi = pfit[:9].reshape(3,3)
print ("%.6f "*6)%(indexing.ubitocellpars(ubi))
print pfit[9:12]
self.g = grain( ubi, pfit[9:12].copy())
if __name__=="__main__":
h = h5py.File(sys.argv[1],"r")
assert sys.argv[2] in h.keys(), h.keys()
c = h[sys.argv[2]]
p = read_par_file(sys.argv[3])
gf = read_grain_file(sys.argv[4])
tol = float(sys.argv[5])
sc = c['sc'][:]
fc = c['fc'][:]
omega = c['omega'][:]
cyf = cyfit( p )
cyf.setscfc( sc, fc )
hkl = np.zeros( cyf.XL.shape, np.float)
drlv = np.zeros( cyf.XL.shape[0], np.float)
kcalc = np.zeros( cyf.XL.shape, np.float)
rs = []
r_omega = np.array(omega*np.pi/180.0,np.float)
start = time.clock()
