def refit_makemap(colf, pars, grains): """ Takes a columnfile, parameters and list of grains and repeats the refinement of each grain, keeping the same grain assignments Returns : new grains """ global TESTING for i, g in enumerate(grains): d = colf.copy() d.filter(d.labels == i) # Take peaks belonging to this grain only sc = d.sc fc = d.fc om = d.omega hkls = np.array((d.h, d.k, d.l)) if i == 1004: TESTING = 3 # Get new t, UB, S t, UB, S = fitone(g.UB, g.translation, sc, fc, om, hkls, pars) for ncycle in range(5): t, UB, S = fitone(UB, t, sc, fc, om, hkls, pars) if S.sh_esd.max() < 1e-10: 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
def fit_ubi_omega(self): print indexing.ubitocellpars(self.g.ubi) f = self.omegacalc_ub res = scipy.optimize.leastsq( f, self.p0, full_output=1) pfit, pcov, info, errmsg, ier = res ub = pfit.reshape(3,3) ubi = np.linalg.inv(ub) print indexing.ubitocellpars(ubi)
def do_fit_trans(self): f = self.fit_trans p0 = self.p0.copy() # p0[:-3]=0.0 #print p0,"call d0" #d0 = f(p0) if 0: for i in range(len(p0)): pt = p0.copy() pt[i] = p0[i]+0.001 from matplotlib.pylab import clf, ion, title, plot, show print pt - p0, pt ion() clf() title("%d"%(i)) plot(d0, f(pt) - d0, ",") show() if raw_input()[0] != " ": break res = scipy.optimize.leastsq( f, p0, full_output=1) 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())
def ferraris_and_ivaldi(ubi, tol=0.001): """ Acta Cryst (1983) A39 595-596 Determine the multiplicities of vectors in a computed powder pattern Match these to multiplicities according to lattice types ... appeals to powder person Tolerance is for grouping vector lengths. """ cpar = ubitocellpars(ubi) cell = unitcell(cpar) dlim = cell.ds(np.array([7, 7, 7])) cell.makerings(dlim, tol) mult = [len(cell.ringhkls[d]) for d in cell.ringds] mx = max(mult) mn = min(mult) cases = { (2, 2): fi_triclinic, (4, 2): fi_monoclinic, # (8, 2) : fi_orthorhombic, # (12, 2) : fi_rhombohedral, # (16, 2) : fi_tetragonal, # (24, 2) : fi_hexagonal, # (48, 2) : fi_cubic }
def makehexagonal( ubi ): """ Finds a nearby hexagonal cell """ cp = indexing.ubitocellpars( ubi ) a = (cp[0]+cp[1])/2 cell = unitcell( (a,a,cp[2],90,90,120),"P") u = indexing.ubitoU( ubi ) ub = np.dot( u, cell.B ) return np.linalg.inv( ub )
def test_fft(): gv = get_eu_gv() from ImageD11.fft_index_refac import grid from ImageD11.indexing import ubitocellpars, write_ubi_file,\ refine g = grid( np = 128, mr = 1.0, nsig = 20, minlen = 3. ) g.gv_to_grid_new(gv) g.fft() g.props() g.peaksearch(open("eu.patterson_pks","w")) g.read_peaks("eu.patterson_pks") vecs = g.UBIALL order = argsort( g.colfile.sum_intensity )[::-1] min_pks = 300 try: for i in order: print vecs[i], g.colfile.sum_intensity[i] for j in order[i:]: for k in order[j:]: print i,j,k try: l = lattice( vecs[i], vecs[j], vecs[k], space='real') t = 0.1 ref = refine( l.vi, gv, t) l = lattice( ref[0], ref[1], ref[2], space='real') print "UBI:" print l.vi print ubitocellpars(l.vi) s = l.score_recip( gv , t ) print "Indexes",s ,"at tolerance",t except: import traceback print traceback.print_exc() raise Exception("error") if s > min_pks: write_ubi_file( "trial.ubi", [ l.vi ] ) raise Exception("Really bad control structure") except: import traceback print traceback.print_exc() print "Got something"
def forwards_project( gr, pars, detector_size, spatial, dsmax, gid): latt = "P" for k in pars.parameters.keys(): if k.startswith("cell_lattice"): latt = pars.get(k) cell = unitcell.unitcell( indexing.ubitocellpars( gr.ubi ), latt ) ds_hkl = cell.gethkls( dsmax ) hkls = np.array( [ x[1] for x in ds_hkl] ) gvecs = np.dot( gr.ub, hkls.T ) wvln, wedge, chi = [ pars.get(x) for x in "wavelength", "wedge", "chi" ] tth, (eta1, eta2), (omega1, omega2) = transform.uncompute_g_vectors( gvecs, wvln, wedge=wedge, chi=chi) osign = float(pars.get("omegasign")) if osign != 1: print("# Flipping omegasign %f"%(osign)) np.multiply( omega1, osign, omega1 ) np.multiply( omega2, osign, omega2 ) pars.set( "t_x", gr.translation[0] ) pars.set( "t_y", gr.translation[1] ) pars.set( "t_z", gr.translation[2] ) fc1, sc1 = transform.compute_xyz_from_tth_eta(tth, eta1, omega1, **pars.parameters) fc2, sc2 = transform.compute_xyz_from_tth_eta(tth, eta2, omega2, **pars.parameters) # Now make a single list of output stuff: alltth = np.concatenate( (tth, tth)) alleta = np.concatenate( (eta1, eta2) ) allsc = np.concatenate( (sc1, sc2) ) allfc = np.concatenate( (fc1, fc2) ) sraw = np.zeros(allsc.shape) fraw = np.zeros(allsc.shape) for i,(s,f) in enumerate(zip( allsc, allfc )): sraw[i], fraw[i] = spatial.distort( s, f ) allomega = np.concatenate( (omega1, omega2) ) allhkls = np.concatenate( (hkls, hkls) ) order = np.argsort( allomega ) # output ? # omega in range # peak in detector # etc fmt = " % -4d % -3d % -3d % -3d % 8.4f % 7.2f % 8.2f % 8.2f % 8.2f % 8.2f % 8.2f" strs = [] for i in order: s, f, o = sraw[i], fraw[i], allomega[i] if alltth[i] == 0: continue if inscan( s, f, o, detector_size): line = fmt%(gid,allhkls[i][0],allhkls[i][1],allhkls[i][2], alltth[i], alleta[i], allomega[i], allsc[i], allfc[i], sraw[i], fraw[i] ) strs.append( (allomega[i], line) ) # to be omega sortable return strs
def test_strain_ref(self): from xfab.tools import ubi_to_u_and_eps dzero_cell = indexing.ubitocellpars( self.ubi0 ) u, eps_xfab_ref_e6 = ubi_to_u_and_eps( self.ubi, dzero_cell ) dgt = finite_strain.DeformationGradientTensor( self.ubi, self.ub0 ) eps_new = dgt.finite_strain_ref( m=0.5 ) self.assertTrue( np.allclose( dgt.U, u ) ) self.assertTrue( np.allclose( dgt.U, self.u ) ) self.assertTrue( np.allclose( finite_strain.symm_to_e6(eps_new), eps_xfab_ref_e6 ) ) self.assertTrue( np.allclose( finite_strain.e6_to_symm(eps_xfab_ref_e6), eps_new ) )
def test_strain_lab(self): from xfab.tools import ubi_to_u_and_eps dzero_cell = indexing.ubitocellpars( self.ubi0 ) u, eps_xfab_ref_e6 = ubi_to_u_and_eps( self.ubi, dzero_cell ) emat = finite_strain.e6_to_symm( eps_xfab_ref_e6 ) Exfab = np.dot(np.dot( u, emat), u.T ) dgt = finite_strain.DeformationGradientTensor( self.ubi, self.ub0 ) eps_new = dgt.finite_strain_lab( m=0.5 ) self.assertTrue( np.allclose( dgt.U, u ) ) self.assertTrue( np.allclose( dgt.U, self.u ) ) self.assertTrue( np.allclose( eps_new, Exfab ) )
def test_fft(): gv = get_eu_gv() from ImageD11.fft_index_refac import grid from ImageD11.indexing import ubitocellpars, write_ubi_file,\ refine g = grid(np=128, mr=1.0, nsig=20) g.gv_to_grid_new(gv) g.fft() g.props() g.peaksearch(open("eu.patterson_pks", "w")) g.read_peaks("eu.patterson_pks") vecs = rc_array(g.UBIALL.T, direction='col') assert vecs.shape == (3, g.colfile.nrows) order = argsort(g.colfile.sum_intensity)[::-1] vecs = take(vecs, order, axis=1) min_pks = 300 ntry = 0 assert g.gv.shape[1] == 3 tv = rc_array(g.gv, direction='row') print "Finding lattice l1 from patterson" l1 = find_lattice(vecs, min_vec2=9, test_vecs=tv, n_try=20) print "r2c == ubi matrix" print l1.r2c print "scores", l1.score(tv) print "cell", ubitocellpars(l1.r2c) l1.r2c = refine(l1.r2c, g.gv, tol=0.1) l1.c2r = inv(l1.r2c) print "With refine", l1.score(tv) print "cell", ubitocellpars(l1.r2c) print "Finding lattice l2 with gvectors to test" l2 = find_lattice(vecs, min_vec2=9, n_try=20, test_vecs=tv) print "r2c == ubi matrix" print l2.r2c print "scores", l2.score(tv) print "cell", ubitocellpars(l2.r2c) l2.r2c = refine(l2.r2c, g.gv, tol=0.1) l2.c2r = inv(l2.r2c) print "With refine", l2.score(tv) print "cell", ubitocellpars(l2.r2c) return
def makemap(self): """ Generate a map fit versus position - no args? """ for m in self.ubisread: g = grain(m) self.scandata=self.allscandata.copy() self.compute_gv(g) h=np.dot(g.ubi,np.transpose(self.gv)) hint=np.floor(h+0.5).astype(np.int) # rounds down diff=h-hint drlv=np.sqrt(np.sum(diff*diff,0)) indices = np.compress(drlv < 0.05, list(range(self.scandata.shape[0]))) print(indices.shape,"hello") self.scandata = self.allscandata[indices] npts = 10 for i in range(npts): for j in range(npts): x=(i-npts*0.5)*1000/npts y=(j-npts*0.5)*1000/npts g.translation[0]=x g.translation[1]=y self.compute_gv(g) for tol in [ 0.1]: mat = g.ubi.copy() npks = closest.score_and_refine(mat, self.gv, tol) # 2nd time with refined npks = closest.score_and_refine(mat, self.gv, tol) h=np.dot(mat,np.transpose(self.gv)) hint=np.floor(h+0.5).astype(np.int) # rounds down diff=h-hint drlv=np.sqrt(np.sum(diff*diff,0)) tthscore = np.sum(np.sum(hint*diff) * np.sum(hint*diff) / np.sum(h*h)) print(x,y, tol, "%5d"%(npks),sum(drlv)/drlv.shape[0],\ tthscore/drlv.shape[0],indexing.ubitocellpars(mat), end=' ') print() sys.stdout.flush() print() print() print()
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 lattice_powder(ubi, tol=0.01): a, b, c = np.asarray(ubi) nmax = 5 vecs = [] lens = [] for ai in range(-nmax, nmax): for bi in range(-nmax, nmax): for ci in range(-nmax, nmax): vec = ai * a + bi * b + ci * c modv = np.sqrt(np.dot(vec, vec)) lens.append(modv) vecs.append(vec) order = np.argsort(lens) lens = np.take(lens, order) vecs = np.take(vecs, order, axis=0) steps = (lens[1:] - lens[:-1]) / lens[1:] # diff divided by upper gaps = steps > tol rings = np.cumsum(gaps) mults, bins = np.histogram(rings, bins=np.arange(-0.5, rings[-1] + 0.5, 1)) print(rings) print(mults) nr = min(10, rings.max()) for i in range(nr, 0, -1): # this ring: M = mults[i] print("Powder ring", i, "multiplicity", M) print(" Angles between vectors:") vl = vecs[1:][rings == i] vll = lens[1:][rings == i] for j in range(M): print("%2d:" % (j), vl[j], vll[j]) print(" ", end="") for j in range(M - 1, 0, -1): print("%7d" % (j), end=" ") print() for j in range(M - 1): print(" %2d: " % (j), end="") for k in range(M - 1, j, -1): print("%7.3f" % (vecang(vl[j], vl[k])), end=" ") print() print("Cell pars before", ubitocellpars(ubi))
def add_voxel_to_field(self, voxel, field_recons, row, col, params): cell = indexing.ubitocellpars(voxel.ubi) field_recons['a'][row, col] = cell[0] field_recons['b'][row, col] = cell[1] field_recons['c'][row, col] = cell[2] field_recons['alpha'][row, col] = cell[3] field_recons['beta'][row, col] = cell[4] field_recons['gamma'][row, col] = cell[5] rod = voxel.Rod field_recons['rod1'][row, col] = rod[0] field_recons['rod2'][row, col] = rod[1] field_recons['rod3'][row, col] = rod[2] ubi = np.ravel(voxel.ubi, order='C') field_recons['UBI11'][row, col] = ubi[0] field_recons['UBI12'][row, col] = ubi[1] field_recons['UBI13'][row, col] = ubi[2] field_recons['UBI21'][row, col] = ubi[3] field_recons['UBI22'][row, col] = ubi[4] field_recons['UBI23'][row, col] = ubi[5] field_recons['UBI31'][row, col] = ubi[6] field_recons['UBI32'][row, col] = ubi[7] field_recons['UBI33'][row, col] = ubi[8] U, eps_cry = tools.ubi_to_u_and_eps(voxel.ubi, self.extract_cell(params)) eps_cry_33 = np.array([[eps_cry[0], eps_cry[1], eps_cry[2]], [eps_cry[1], eps_cry[3], eps_cry[4]], [eps_cry[2], eps_cry[4], eps_cry[5]]]) sample_strain = np.dot(U, np.dot(eps_cry_33, np.transpose(U))) field_recons['E11'][row, col] = sample_strain[0, 0] field_recons['E12'][row, col] = sample_strain[0, 1] field_recons['E13'][row, col] = sample_strain[0, 2] field_recons['E22'][row, col] = sample_strain[1, 1] field_recons['E23'][row, col] = sample_strain[1, 2] field_recons['E33'][row, col] = sample_strain[2, 2]
def main(): """ A user interface """ import sys, time, os, logging start = time.time() root = logging.getLogger('') root.setLevel(logging.WARNING) try: from optparse import OptionParser parser = OptionParser() parser = get_options(parser) options, args = parser.parse_args() except SystemExit: raise except: parser.print_help() print("\nProblem with your options:") raise if options.output is None: print("You must supply an output file (-o vol.h5)") sys.exit() if os.path.exists(options.output): print("I would overwrite your output file", options.output) print("If you really want that then delete it first and re-run") sys.exit() try: if options.pars is None: print("You must supply a parameter file, -p file.pars") sys.exit() pars = parameters.parameters() pars.loadparameters(options.pars) print("Got parameters from", options.pars) pd = pars.get_parameters() names = list(pd.keys()) names.sort() for name in names: print("%30s %s" % (name, pd[name])) except: print("Problem with parameters:", options.pars) raise try: if options.ubifile is None: print("You must supply an input ubifile") ubi = indexing.readubis(options.ubifile)[0] print("UBI:\n", ubi) print("Cell parameters:") print("%.5f %.5f %.5f %.4f %.4f %.4f" % \ indexing.ubitocellpars(ubi)) except: print("Problem with ubi file:", options.ubifile) raise if options.maskfilename is not None: from fabio.openimage import openimage try: mask = (openimage(options.maskfilename).data == 0) except: print("Problem with your mask image", options.maskfilename) raise print("Using a mask from", options.maskfilename) print("percent of image used %.3f" % (100.0 * mask.sum() / mask.shape[0] / mask.shape[1])) else: mask = None first_image = True nimage = 0 imagefiles = ImageD11_file_series.get_series_from_options(options, args) print("Subslicing by", options.subslice) try: for fim in imagefiles: if first_image: # allocate volume, compute k etc first_image = False mapper = rsv_mapper(fim.data.shape, pars, ubi, options.spline, np=options.npixels, border=options.border, maxpix=options.maxpix, mask=mask # FIXME omegarange ) logging.info("Setting up time %.4f s" % (time.time() - start)) ltp = time.time() om = float(fim.header['Omega']) oms = float(fim.header['OmegaStep']) for i in range(options.subslice): print(".", end=' ') omv = om + i * oms / options.subslice # ==1 : 0*s/1 # ==2 : 0*s/2 , 1*s/2 # ==3 : 0*s/3 , 1*s/3, 2*s/3 etc mapper.add_image(omv, fim.data) nimage = nimage + 1 print(" %d %.3f %.4f s, %.4f s" % (nimage, om, time.time() - ltp, time.time() - start)) if options.images is not None: if nimage >= options.images: break except KeyboardInterrupt: print("\nCaught a control-c") if nimage > 0: print("Problem, trying to save volume so far to:", options.output) mapper.writevol(options.output) print("Saved what I had") sys.exit() except: print("\nAn error occured") if nimage > 0: print("Problem, trying to save volume so far to:", options.output) mapper.writevol(options.output) print("Saved what I had") raise if nimage > 0: mapper.writevol(options.output)
def pairs(self, hkl1, hkl2, cos_tol=0.02, hkl_tol=0.1): """ We only look for reflection pairs matching a single hkl pairing """ import time start = time.time() w = self.transformpars.get("wavelength") tth1 = get_tth(self.unitcell.ds(hkl1), w) tth2 = get_tth(self.unitcell.ds(hkl2), w) tthtol = self.transformpars.get("fit_tolerance") allinds = np.arange(self.cf.nrows) ind1 = allinds[abs(self.cf.tth - tth1) < tthtol] ind2 = allinds[abs(self.cf.tth - tth2) < tthtol] angle, cosangle = self.unitcell.anglehkls(hkl1, hkl2) print("Angle, cosangle", angle, cosangle, hkl1, hkl2) assert angle > 1 and angle < 179, "hkls are parallel" g = np.array((self.cf.gx, self.cf.gy, self.cf.gz), np.float) n = g / self.cf.modg gvf = g.T.copy() n1 = n[:, ind1] n2 = n[:, ind2] pairs = [] j = np.arange(n2.shape[1]) # from unitcell.orient h1c = unit(np.dot(self.unitcell.B, hkl1)) h2c = unit(np.dot(self.unitcell.B, hkl2)) t1c = unit(h1c) t3c = unit(np.cross(h1c, h2c)) t2c = unit(np.cross(h1c, t3c)) T_c = np.array([t1c, t2c, t3c]) T_g = np.zeros((3, 3)) for i, this_n1 in enumerate(n1.T): cosa = np.dot(this_n1, n2) goodones = j[abs(cosa - cosangle) < cos_tol] # t1 is along g1 # t2 is plane of both: g1x(g1xg2) # t3 is perpendicular to both #if i%100==0: # print i,time.time()-start,len(n1.T) for k in goodones: this_n2 = n2[:, k] T_g[0] = this_n1 T_g[2] = unit(np.cross(this_n1, this_n2)) T_g[1] = unit(np.cross(this_n1, T_g[2])) U = np.dot(T_g.T, T_c) ub = np.dot(U, self.unitcell.B) ubi = np.linalg.inv(ub) ubio = ubi.copy() npks = cImageD11.score(ubi, gvf, hkl_tol) pairs.append((ind1[i], ind2[k], U, ubi)) print(npks, end=' ') ubi, trans = self.refine(ubi, np.zeros(3, np.float), tol=hkl_tol) inds, hkls = self.assign(ubi, trans, hkl_tol) ubi, trans = self.refine(ubi, trans, inds=inds, hkls=hkls, tol=hkl_tol) print(npks, ubi) print("cell: ", 6 * "%.6f " % (indexing.ubitocellpars(ubi))) print("position: ", trans) print() self.pairscache = pairs print(time.time() - start, "for", len(pairs), n1.shape, n2.shape) return pairs
inds=inds, hkls=hkls, tol=tol) g.translation = t g.set_ubi(ubi) else: inds = np.compress(c.labels == k, inds) hkls = np.compress(c.labels == k, allhkls) for j in range(3): ubi, t = i.refine(g.ubi, translation=g.translation, inds=inds, hkls=hkls, tol=tol) g.translation = t g.set_ubi(ubi) print(k, len(inds), 6 * "%.8f " % (indexing.ubitocellpars(ubi))) print("\t", t) ImageD11.grain.write_grain_file(sys.argv[5], gl) else: i.updatecolfile() i.tthcalc() print("Calling assign") i.assigntorings() hkl1 = [int(h) for h in sys.argv[3].split(",")] hkl2 = [int(h) for h in sys.argv[4].split(",")] print("Calling pairs") i.pairs(hkl1, hkl2) # e.g. python indexer.py ../test/demo/eu3.pars ../test/demo/eu.flt 2,0,0 0,0,4
def cpfromub( ubf ): ub = np.reshape( ubf, (3,3) ) return np.array(indexing.ubitocellpars( np.linalg.inv( ub ) ))
gfl = [] ng = 0 # Take old peak assignments: if 1: print("Using existing peak assignments") inds = np.arange(o.colfile.nrows, dtype=int) for i, gref in enumerate(gl): gref.pks = np.compress(o.colfile.labels == i, inds) tols = [ None, ] * 3 else: tols = [0.05, 0.01, 0.0075] for gref in gl: print("BEFORE: ", 3 * "% 7.3f " % tuple(gref.translation), 6 * "%.6f " % (ubitocellpars(gref.ubi))) for ii, tol in enumerate(tols): #print gref.translation gref = o.refine(gref, tol=tol) #print i,gref.npks # gref.pks = None # re-assign after convergence # gref = o.refine( gref, tol=0.0075) gfl.append(gref) ng += 1 print(ng, ng * 100.0 / len(gl), "%.2f " % (time.time() - start), gref.npks, end=' ') print((3 * "%.4f ") % tuple(gref.translation), end=' ')
#print l.score(all_gvecs[3:5], tol = options.tol) #print l.remainders( all_gvecs[3:5]) all = len(all_gvecs) npks = l.score(all_gvecs, tol=options.tol) if (1.0 * npks / len(all_gvecs)) < options.fraction_indexed: break dr = indexing.calc_drlv2(l.r2c, all_gvecs) t2 = options.tol * options.tol # print "tol, dr",t2,dr.shape, [d for d in dr[:10]] # print it !!! n2 = np.sum(np.where(dr < t2, 1, 0)) n3 = np.sum(np.where(dr > t2, 1, 0)) assert npks == n2, "debug scoring" assert n3 == len(all_gvecs) - npks, "debug scoring" print l.r2c print "Unit cell:", (6 * "%.6f ") % indexing.ubitocellpars(l.r2c) # Put this grain in the output list ubis.append(l.r2c) # Remove from the gvectors drlv2 = indexing.calc_drlv2(l.r2c, cur_gvecs) # print drlv2[:20] # print cur_gvecs.shape # print drlv2.shape,drlv2[:10],options.tol*options.tol cur_gvecs = rc_array.rc_array(np.compress( drlv2 > options.tol * options.tol, cur_gvecs, axis=0), direction='row') print "Lattice found, indexes", npks, "from all", all print "Number of unindexed peaks remaining %d" % (len(cur_gvecs))
for ubifile in sys.argv[1:]: print("Reading",ubifile, end=' ') try: ul = indexing.readubis(ubifile) except: print("error") continue print() print("i a b c alpha beta gamma volume") cell_all = [] volume = [] for u,i in zip(ul,list(range(len(ul)))): print(i, end=' ') cell = indexing.ubitocellpars(u) vol = cell[0]*cell[1]*cell[2]*numpy.sin(cell[3]*numpy.pi/180.)*numpy.sin(cell[4]*numpy.pi/180.)*numpy.sin(cell[5]*numpy.pi/180.) print("%.5f "*6 % cell + "%.5f" %vol) cell_all.append(cell) volume.append(vol) continue #print u red = try_to_reduce(u) #print red #print u if (red != u).any(): print("Reduced ubi") print(red) print("%.5f "*6 % indexing.ubitocellpars(red)) cell_all = numpy.asarray(cell_all)