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()