def fitgrain(options): """ Fits grains to a dataset using all peaks within tol """ func = getattr(refinegrains, options.latticesymmetry) o = refinegrains.refinegrains(tolerance=options.tol, latticesymmetry=func, OmFloat=options.omega_float, OmSlop=options.omega_slop) o.loadparameters(options.parfile) o.readubis(options.ubifile) o.loadfiltered(options.fltfile) o.generate_grains() #o.refineubis(quiet = False) #print o.grains.keys() #print "#pks",o.grains[(0,"0.flt")].x.shape o.parameterobj.varylist = options.varylist for p in options.fixlist: try: o.parameterobj.varylist.remove(p) except: pass logging.info("Varying " + str(o.parameterobj.varylist)) #print "#pks",o.grains[(0,"0.flt")].x.shape o.fit(maxiters=options.steps) #print "#pks",o.grains[(0,"0.flt")].x.shape o.refineubis(quiet=False) o.saveparameters(options.newparfile) # ul = [g.ubi for g in o.grains.values()] # indexing.write_ubi_file(options.newubifile, ul) # Keep the original ordering and add translation information o.savegrains(options.newubifile, sort_npks=False)
def makemap(options): try: if options.tthrange is None: tthr = (0., 180.) else: tthr = options.tthrange if len(tthr) == 1: tthr = (0, tthr[0]) print("Using tthrange", tthr) func = getattr(ImageD11.refinegrains, options.latticesymmetry) o = refinegrains(intensity_tth_range=tthr, latticesymmetry=func, OmFloat=options.omega_float, OmSlop=options.omega_slop) except: raise o = refinegrains() o.loadparameters(options.parfile) print("got pars") o.loadfiltered(options.fltfile) print("got filtered") o.readubis(options.ubifile) if options.symmetry is not "triclinic": # Grainspotter will have already done this print("transform to uniq") o.makeuniq(options.symmetry) print("got ubis") o.tolerance = float(options.tol) print("generating") o.generate_grains() print("Refining posi too") # o.refineubis(quiet = False , scoreonly = True) print("Refining positions too") o.refinepositions() print("Done refining positions too") # o.refineubis(quiet = False , scoreonly = True) o.savegrains(options.newubifile, sort_npks=options.sort_npks) col = o.scandata[options.fltfile].writefile(options.fltfile + ".new") if hasattr(options, "newfltfile") and options.newfltfile is not None: print("re-assignlabels") o.assignlabels() col = o.scandata[options.fltfile].copy() print("Before filtering", col.nrows) col.filter(col.labels < -0.5) # print col.labels[:10] print("After filtering", col.nrows) col.writefile(options.newfltfile)
def domap(pars, colfile, grains, gridpars): """ mapping function - does what makemap.py does, but in a function """ if 'FITPOS' not in gridpars: gridpars['FITPOS'] = True OmSlop = gridpars['OMEGAFLOAT'] OmFloat = OmSlop > 0 # ss = sys.stdout # turns off printing if gridpars['NUL']: NUL = open(nulfile, "w") sys.stdout = NUL for tol in gridpars['TOLSEQ']: o = refinegrains.refinegrains( OmFloat=OmFloat, OmSlop=OmSlop, tolerance=tol, intensity_tth_range=(0, 180), ) o.parameterobj = pars # o.loadfiltered ... o.scannames = ["internal"] o.scantitles = colfile.titles o.scandata["internal"] = colfile o.tolerance = tol # o.readubis( grainsfile ) for i, g in enumerate(grains): name = i o.grainnames.append(i) o.ubisread[name] = g.ubi o.translationsread[name] = g.translation if gridpars['SYMMETRY'] != "triclinic": o.makeuniq(gridpars['SYMMETRY']) o.generate_grains() if gridpars['FITPOS']: o.refinepositions() else: o.assignlabels() for key in o.grains.keys(): g = o.grains[key] g.set_ubi(o.refine(g.ubi, quiet=False)) # This fills in the uniq for each grain o.savegrains(nulfile, sort_npks=False) if 'NUNIQ' in gridpars: keep = lambda g: g.nuniq > gridpars['NUNIQ'] and g.npks > gridpars[ 'NPKS'] else: keep = lambda g: g.npks > gridpars['NPKS'] gl = [g for g in o.grains.values() if keep(g)] if len(gl) == 0: break grains = gl if gridpars['NUL']: sys.stdout = ss return gl
def filtergrain(options): """ Filter a peaks file according to which peaks are indexed """ o = refinegrains.refinegrains(options.tol) o.loadparameters(options.parfile) o.readubis(options.ubifile) o.loadfiltered(options.fltfile) o.generate_grains() for gn in o.grainnames: o.reset_labels(options.fltfile) o.set_translation(gn, options.fltfile) o.compute_gv(gn, options.fltfile) drlv2 = indexing.calc_drlv2(o.grains[(gn, options.fltfile)].ubi, o.gv) o.scandata[options.fltfile].filter(drlv2 > options.tol * options.tol) print(gn, o.scandata[options.fltfile].nrows) o.scandata[options.fltfile].writefile(options.newfltfile)
def domap(pars, colfile, grains, gridpars): """ mapping function - does what makemap.py does, but in a function """ OmSlop = gridpars['OMEGAFLOAT'] OmFloat = OmSlop > 0 # ss = sys.stdout # turns off printing if gridpars['NUL']: NUL = open(nulfile, "w") sys.stdout = NUL for tol in gridpars['TOLSEQ']: o = refinegrains.refinegrains( OmFloat=OmFloat, OmSlop=OmSlop, tolerance=tol, intensity_tth_range=(0, 180), ) o.parameterobj = pars # o.loadfiltered ... o.scannames = ["internal"] o.scantitles = colfile.titles o.scandata["internal"] = colfile o.tolerance = tol # o.readubis( grainsfile ) for i, g in enumerate(grains): name = i o.grainnames.append(i) o.ubisread[name] = g.ubi o.translationsread[name] = g.translation if gridpars['SYMMETRY'] is not "triclinic": o.makeuniq(gridpars['SYMMETRY']) o.generate_grains() o.refinepositions() # This fills in the uniq for each grain o.savegrains(nulfile, sort_npks=False) gl = [g for g in o.grains.values() if g.npks > gridpars['NPKS']] if len(gl) == 0: break grains = gl if gridpars['NUL']: sys.stdout = ss return gl
def fit(tol): o = refinegrains.refinegrains( OmFloat=OmFloat, OmSlop=OmSlop, tolerance=tol, intensity_tth_range=(0, 180), ) o.parameterobj = pars # o.loadfiltered ... o.scannames = ["internal"] o.scantitles = colfile.titles o.scandata["internal"] = colfile o.tolerance = tol o.readubis(grainsfile) if symmetry != "triclinic": o.makeuniq(symmetry) o.generate_grains() o.refinepositions() return o
def domap(OmFloat, OmSlop, pars, colfile, grainsfile, tolseq=[0.03, 0.02, 0.01], symmetry="triclinic"): """mapping function - does what makemap.py does""" global NPKS ss = sys.stdout # turns off printing for tol in tolseq: sys.stdout = NUL o = refinegrains.refinegrains( OmFloat=OmFloat, OmSlop=OmSlop, tolerance=tol, intensity_tth_range=(0, 180), ) o.parameterobj = pars # o.loadfiltered ... o.scannames = ["internal"] o.scantitles = colfile.titles o.scandata["internal"] = colfile o.tolerance = tol o.readubis(grainsfile) if symmetry != "triclinic": o.makeuniq(symmetry) o.generate_grains() o.refinepositions() gl = [x for x in list(o.grains.values()) if x.npks > NPKS] sys.stdout = ss if len(gl) == 0: print("I killed all your grains!") break else: print("Keeping", len(gl), "from", len(list(o.grains.values())), "grains with at least", NPKS, "peaks", tol) grain.write_grain_file(grainsfile, gl) return len(gl)
def main(args): # set up peak-finding print() r = refinegrains() r.loadparameters(args.parfile) r.loadfiltered(args.fltfile) r.readubis(args.ubifile) r.generate_grains() r.tolerance = float(args.tol) p = parameters.parameters() p.loadparameters(args.parfile) #*********************** BEGIN USER INPUT ***********************# print() param_range = np.array([ # MIN MAX #---------------------------- [ r.parameterobj.parameters['distance'] * (1 - args.dd), r.parameterobj.parameters['distance'] * (1 + args.dd), ], #dd [ r.parameterobj.parameters['y_center'] - args.dy, r.parameterobj.parameters['y_center'] + args.dy, ], #dy [ r.parameterobj.parameters['z_center'] - args.dz, r.parameterobj.parameters['z_center'] + args.dz, ], #dz [ r.parameterobj.parameters['tilt_x'] - args.dtx, r.parameterobj.parameters['tilt_x'] + args.dtx, ], #dtx [ r.parameterobj.parameters['tilt_y'] - args.dty, r.parameterobj.parameters['tilt_y'] + args.dtz, ], #dty [ r.parameterobj.parameters['tilt_z'] - args.dtz, r.parameterobj.parameters['tilt_z'] + args.dtz, ], #dtz [ r.parameterobj.parameters['wedge'] - args.dw, r.parameterobj.parameters['wedge'] + args.dw, ] ]) #dw #************************* END USER INPUT *************************# # read and record initial optimal paramter values init_pars = open(args.parfile, 'r') init_pars_array = np.genfromtxt(init_pars, usecols=1) distance = init_pars_array[8] y_center = init_pars_array[25] z_center = init_pars_array[27] tilt_x = init_pars_array[20] tilt_y = init_pars_array[21] tilt_z = init_pars_array[22] wedge = init_pars_array[24] p_opt_array = [distance, y_center, z_center, tilt_x, tilt_y, tilt_z, wedge] # create list of parameter names all_param_names = [ 'distance', 'y_center', 'z_center', 'tilt_x', 'tilt_y', 'tilt_z', 'wedge' ] param_names = [] if args.dd != 0: param_names.append('distance') if args.dy != 0: param_names.append('y_center') if args.dz != 0: param_names.append('z_center') if args.dtx != 0: param_names.append('tilt_x') if args.dty != 0: param_names.append('tilt_y') if args.dtz != 0: param_names.append('tilt_z') if args.dw != 0 and (args.experiment == 'FF' or args.experiment == 'ff'): param_names.append('wedge') print('varying:') print(param_names) print() # find number of peaks using initial optimal parameter values for i, name in enumerate(all_param_names): r.parameterobj.parameters[name] = p_opt_array[i] r.assignlabels() ## try here... n, e = scor(r) print(('Peaks found before parameter refinement: %d' % n)) print() # parameter refinement iteration loop for current_iteration in range(args.iterations): if current_iteration > 0: ## Update range on parameters param_range[0, 0] = r.parameterobj.parameters['distance'] * (1 - args.dd) param_range[0, 1] = r.parameterobj.parameters['distance'] * (1 + args.dd) param_range[1, 0] = r.parameterobj.parameters['y_center'] - args.dy param_range[1, 1] = r.parameterobj.parameters['y_center'] + args.dy param_range[2, 0] = r.parameterobj.parameters['z_center'] - args.dz param_range[2, 1] = r.parameterobj.parameters['z_center'] + args.dz param_range[3, 0] = r.parameterobj.parameters['tilt_x'] - args.dtx param_range[3, 1] = r.parameterobj.parameters['tilt_x'] + args.dtx param_range[4, 0] = r.parameterobj.parameters['tilt_y'] - args.dty param_range[4, 1] = r.parameterobj.parameters['tilt_y'] + args.dty param_range[5, 0] = r.parameterobj.parameters['tilt_z'] - args.dtz param_range[5, 1] = r.parameterobj.parameters['tilt_z'] + args.dtz param_range[6, 0] = r.parameterobj.parameters['wedge'] - args.dw param_range[6, 1] = r.parameterobj.parameters['wedge'] + args.dw # skip parameter refinement? if args.skip_par_ref: print('Option to skip parameter refinement is set to ON.' 'GrainSweeper will use parameters values from the nf_X.par' 'file, unless the opt_par_values_nf_X.txt already exists ' '(in which case values from this .txt file will be used.') print() print('The parameter refinement skipping option can be ' 'toggled/overridden in the tweakpars.py script.') print() break ## set initial optimal parameters for i, name in enumerate(all_param_names): r.parameterobj.parameters[name] = p_opt_array[i] # create 3D array where: # rows = parameter variation increments # cols = parameter value, peaks found, e (3 cols total) # slices = parameters varied param_peaks = np.zeros(shape=(args.steps, 3, len(param_names))) ## find peaks for each par variation, fit Gaussian to curve, and find ## optimal par values for i, name in enumerate(param_names): # for each parameter print() print(('Varying parameter: %s; value: %g' % (name, p_opt_array[all_param_names.index(name)]))) print(' distance y_center z_center tilt_x tilt_y' ' tilt_z wedge peaks found e') var_range = list( np.linspace(param_range[all_param_names.index(name), 0], param_range[all_param_names.index(name), 1], args.steps)) for j, d in enumerate(var_range): # each parameter variation step r.parameterobj.parameters[name] = d dd = r.parameterobj.parameters['distance'] yy = r.parameterobj.parameters['y_center'] zz = r.parameterobj.parameters['z_center'] tx = r.parameterobj.parameters['tilt_x'] ty = r.parameterobj.parameters['tilt_y'] tz = r.parameterobj.parameters['tilt_z'] ww = r.parameterobj.parameters['wedge'] n, e = scor(r) param_peaks[j, :, i] = d, n, e # write values to array print(('%11.1f %9.1f %9.1f %11.6f %11.6f %11.6f %11.6f %10d ' '%11.5f' % (dd, yy, zz, tx, ty, tz, ww, n, e))) # create Gaussian fit p_opt = gauss_fit(param_peaks[:, 0, i], param_peaks[:, 1, i]) if p_opt is None: print('cant fit something that doesnt vary') r.parameterobj.parameters[name] = p_opt_array[ all_param_names.index(name)] continue # create Gaussian xy values, and plot original and fit curves # together x_gauss_steps = np.linspace( param_range[all_param_names.index(name), 0], param_range[all_param_names.index(name), 1], 200) y_gauss_steps = gaussian(x_gauss_steps, *p_opt) plt.xlabel(str(name)) plt.ylabel('peaks found') plt.plot(param_peaks[:, 0, i], param_peaks[:, 1, i]) plt.plot(x_gauss_steps, y_gauss_steps) if args.experiment: figurename = ('%s_param_var_%s_iter%d.pdf' % (args.experiment, name, current_iteration + 1)) else: figurename = ('NEW_param_var_%s_iter%d.pdf' % (name, current_iteration + 1)) plt.savefig(figurename) plt.clf() ## print and record newest updated optimal parameter value, ## print peaks found print(('Optimal parameter value: %.4f' % p_opt[1])) p_opt_array[all_param_names.index(name)] = p_opt[1] r.parameterobj.parameters[name] = p_opt_array[ all_param_names.index(name)] print() n, e = scor(r) # find number of peaks using all optimal #parameter values print(('Peaks found after variation: %d' % n)) # print optimal parameters from current iteration print() print(('Optimal parameter values for parameter refinement' 'iteration %d:' % (current_iteration + 1))) print((' '.join(map(str, all_param_names)))) print((' '.join(map(str, p_opt_array)))) print() # create optimal parameter values file (for importing into shell) if args.experiment: filename = '%s_opt_par_values.ini' % (args.experiment) writeline = args.experiment + '=' + str(n) else: filename = 'NEW_opt_par_values.ini' writeline = 'NEW = ' + str(n) text_file = open(filename, 'w') for i, name in enumerate(all_param_names): text_file.write(str(name) + '=' + str(p_opt_array[i]) + '\n') text_file.write(writeline) text_file.close() # write new paramterfile r.parameterobj.parameters['t_x'] = 0 r.parameterobj.parameters['t_y'] = 0 r.parameterobj.parameters['t_z'] = 0 r.parameterobj.saveparameters(args.outparfile)
def filtergrain(options): """ Filter a peaks file according to which peaks are indexed """ o = refinegrains.refinegrains(tolerance=0.9, OmFloat=options.omega_float, OmSlop=options.omega_slop) o.loadparameters(options.parfile) o.readubis(options.ubifile) if options.grain is None: if len(o.grainnames) == 1: gn = o.grainnames[0] else: for i, gn in zip(list(range(len(o.grainnames))), o.grainnames): logging.info("Choose %d for grain %s" % (i, gn)) gn = o.grainnames[int(input("select which grain "))] else: gn = o.grainnames[int(options.grain)] o.grainnames = [ gn, ] o.loadfiltered(options.fltfile) o.generate_grains() o.assignlabels() o.set_translation(gn, options.fltfile) o.compute_gv(o.grains[(gn, options.fltfile)]) if options.tol is None: for tol in [0.01, 0.025, 0.05, 0.1, 0.15, 0.25, 0.5]: o.tolerance = tol logging.info("tol %f" % (o.tolerance)) o.refineubis(quiet=False, scoreonly=True) o.tolerance = float(input("Enter tolerance ")) options.tol = o.tolerance else: o.tolerance = options.tol matrix = o.grains[(gn, options.fltfile)].ubi o.assignlabels() drlv2 = indexing.calc_drlv2(matrix, o.gv) logging.info("Total peaks before filtering %d" % o.scandata[options.fltfile].nrows) gotpks = o.scandata[options.fltfile].copy() gotpks.filter(gotpks.labels == gn) gotpks.writefile(options.newfltfile) logging.info("Peaks which were indexed %d written to %s" % (gotpks.nrows, options.newfltfile)) # don't bother to copy here as we can overwrite if options.notindexed is not None: notpks = o.scandata[options.fltfile].copy() notpks.addcolumn(o.tth, "tth") notpks.addcolumn(o.eta, "eta") notpks.addcolumn(o.gv[:, 0], "gx") notpks.addcolumn(o.gv[:, 1], "gy") notpks.addcolumn(o.gv[:, 2], "gz") notpks.filter(drlv2 > o.tolerance * o.tolerance) notpks.writefile(options.notindexed) logging.info("Peaks which were not indexed %d written to %s" % (notpks.nrows, options.notindexed)) if options.newubifile is not None: o.scandata[options.fltfile] = gotpks # matrix = o.refine(matrix,quiet=True) grain.write_grain_file(options.newubifile, [o.grains[(gn, options.fltfile)]]) logging.info("Refined ubi in %s " % (options.newubifile))
try: flt = sys.argv[1] par = sys.argv[2] ubi = sys.argv[3] tol = float(sys.argv[4]) if len(sys.argv) > 5: nbins = int(sys.argv[5]) else: nbins = 30 except: print("Usage: %s flt par ubi tol [nbins=30] [omega_slop]" % (sys.argv[0])) sys.exit() if len(sys.argv) > 6: o = refinegrains(OmFloat=True, OmSlop=float(sys.argv[6])) else: o = refinegrains(OmFloat=False) o.loadparameters(par) o.readubis(ubi) o.loadfiltered(flt) o.tolerance = tol o.generate_grains() o.assignlabels() import matplotlib.pylab as pl # indexed peaks only d = o.scandata[flt] d.filter(d.labels >= 0)