def compute_gv(self,g): """ Makes self.gv refer be g-vectors computed for this grain in this scan """ try: xc = self.scantitles.index("xc") except: print(self.scantitles) raise # print self.scandata[scanname].shape x = self.scandata[:,xc] yc = self.scantitles.index("yc") y = self.scandata[:,yc] om = self.scantitles.index("omega") om = self.scandata[:,om] tth,eta = transform.compute_tth_eta( np.array([x, y]) , self.parameters['y-center'], self.parameters['y-size'], self.parameters['tilt-y'], self.parameters['z-center'], self.parameters['z-size'], self.parameters['tilt-z'], self.parameters['distance']*1.0e3, crystal_translation = g.translation, omega = om, axis_orientation1 = self.parameters['wedge'], axis_orientation2 = self.parameters['chi']) self.gv = transform.compute_g_vectors(tth,eta,om, float(self.parameters['wavelength']), self.parameters['wedge']) self.gv = np.transpose(self.gv)
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 test_0_10(self): """ wedge,chi = 0,10 """ w = 0. c = 10. g = transform.compute_g_vectors(self.tth, self.eta, self.omega, self.wvln, wedge=w, chi=c) post = gv_general.wedgechi(wedge=w, chi=c) sol1, sol2, valid = gv_general.g_to_k( g, # self.wvln, axis=np.array([0, 0, -1], np.float), pre=None, post=post) c0 = np.cos(transform.radians(self.omega)) c1 = np.cos(transform.radians(sol1)) c2 = np.cos(transform.radians(sol2)) s0 = np.sin(transform.radians(self.omega)) s1 = np.sin(transform.radians(sol1)) s2 = np.sin(transform.radians(sol2)) err1 = np.absolute(c1 - c0) + np.absolute(s1 - s0) err2 = np.absolute(c2 - c0) + np.absolute(s2 - s0) err = np.minimum(err1, err2) self.assertAlmostEqual(array_diff(err, np.zeros(self.np)), 0, 6)
def get_hkl(self, event): # canvas x and y take the screen coords from the event and translate # them into the coordinate system of the canvas object xpos = self.canvasObject.canvasx(event.x) / self.zoom ypos = self.canvasObject.canvasy(event.y) / self.zoom print "xpos,ypos", xpos, ypos from ImageD11 import transform tth, eta = transform.compute_tth_eta(np.array([[xpos], [ypos]]), **self.parameters) print "omega:", self.omega, type(self.omega) om = np.array([float(self.omega)]) print "tth,eta,om", tth, eta, om self.gv = transform.compute_g_vectors( tth, eta, om, float(self.parameters['wavelength']), self.parameters['wedge']) self.gv = np.transpose(self.gv) s = "" i = 0 for ubi in self.ubisread: h = np.dot(ubi, self.gv.T) print "i=%d" % (i), "hkl= %.2f %.2f %.2f" % tuple(h) i += 1 s += "grain %3d\n h = %.2f k=%.2f l = %.2f\n" % (i, h[0], h[1], h[2]) showinfo( "Right clicked", "You click at %f %f, tth=%f eta=%f omega=%f\n %s" % (xpos, ypos, tth, eta, om, s))
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 runtest(self): g = transform.compute_g_vectors(self.tth, self.eta, self.omega, self.wvln, wedge=self.w, chi=self.c) tth, eta, omega = transform.uncompute_g_vectors(g, self.wvln, wedge=self.w, chi=self.c) # print tth # print eta # print omega print "# w c i tth tth etao etaC omegao omegaC etaC2 omegaC2" for i in range(len(tth)): print self.w, self.c, i, best = np.argmin( np.abs(angmod(np.array(omega)[:, i] - self.omega[i]))) deta = angmod(np.array(eta)[best, i] - self.eta[i]) domega = angmod(np.array(omega)[best, i] - self.omega[i]) print ("%8.2f "*8)%(self.tth[i], tth[i],self.eta[i], eta[best][i],\ self.omega[i], omega[best][i],eta[1-best][i],omega[1-best][i]) self.assertAlmostEqual(self.tth[i], tth[i], 5) self.assertAlmostEqual(deta, 0.0, 5) self.assertAlmostEqual(domega, 0.0, 5)
def get_peak_quantities(self, flt, pars, OMSLOP, origin=[0, 0, 0]): """ Compute twotheta, eta, g-vector for given origin = [x, y] obs: Computes for all peaks generated from all grains. If no origin specified origin is set to [0,0,0] """ pars.parameters['t_x'] = np.ones(flt.nrows) * origin[0] pars.parameters['t_y'] = np.ones(flt.nrows) * origin[1] pars.parameters['t_z'] = np.zeros(flt.nrows) tth, eta = scanning_transform.compute_tth_eta([flt.sc, flt.fc], omega=flt.omega, **pars.parameters) gve = transform.compute_g_vectors(tth, eta, flt.omega, pars.get('wavelength'), wedge=pars.get('wedge'), chi=pars.get('chi')) pars.parameters['t_x'] = 0 pars.parameters['t_y'] = 0 pars.parameters['t_z'] = 0 return tth, eta, gve
def find_vol(self, border, omegarange): """ find limiting volume The four image corners over 360 degrees np is the number of pixels per hkl returns (RSV, NR) RSV min/max in reciprocal space (np*ubi).gv NR number of points == 1+RSV[i][1]-RSV[i][0] """ # Note that ImageD11 peaks are [slow, fast] # 1 2 3 # 4 5 6 # 7 8 9 p1 = [ -border, self.dims[0] / 2, self.dims[0] + border, self.dims[0] / 2, self.dims[0] + border, -border, self.dims[0] + border, -border, self.dims[0] / 2 ] p2 = [ -border, self.dims[1] / 2, self.dims[1] + border, -border, self.dims[1] / 2, self.dims[1] + border, -border, self.dims[1] / 2, self.dims[1] + border ] for i in range(9): p1[i], p2[i] = self.spatial.correct(p1[i], p2[i]) peaks = [p1 * len(omegarange), p2 * len(omegarange)] om = numpy.array(list(omegarange) * 9, numpy.float32) tth, eta = transform.compute_tth_eta(peaks, **self.pars.get_parameters()) #print "tth",tth.min(),tth.max() #print "eta",eta.min(),eta.max() assert om.shape == tth.shape gv = transform.compute_g_vectors(tth, eta, om, self.pars.get('wavelength'), float(self.pars.get('wedge')), float(self.pars.get('chi'))) # Rotate g-vectors into target volume hkls = numpy.dot(self.uspace, gv) # print "Ranges for RSV" bounds = numpy.zeros((3, 2)) npv = numpy.zeros(3) for i in range(3): bounds[i][0] = numpy.floor(hkls[i].min()) bounds[i][1] = numpy.ceil(hkls[i].max()) npv[i] = (bounds[i][1] - bounds[i][0]) + 1 self.bounds = bounds self.rsv = rsv.rsv(npv, bounds=bounds, np=self.np) # Cross your fingers and.... self.rsv.allocate_vol()
def readimage(self, image): from ImageD11 import transform from fabio import openimage self.imageobj = openimage.openimage(image) # map from 2048x2048 to 1024x1024 d = self.imageobj.data.astype(numpy.float32) mi = d.mean() - d.std() * 2 mx = d.mean() * d.std() * 2 shape = self.imageobj.data.shape d = numpy.reshape(numpy.clip(self.imageobj.data, mi, mx), shape) # makes a clipped copy d = (255. * (d - mi) / (mx - mi)) # scale intensity print d.min(), d.max(), d.mean() self.image = numpy.zeros((1024, 1024), numpy.uint8) if d.shape == (2048, 2048): # rebin 2x2 im = (d[::2, ::2] + d[::2, 1::2] + d[1::2, ::2] + d[1::2, 1::2]) / 4 self.image = (255 - im).astype(numpy.uint8).tostring() self.imageWidth = 1024 self.imageHeight = 1024 # make a 2D array of x,y p = [] pk = [] step = 64 r = [[0, 0], [0, step], [step, step], [step, 0]] for i in range(0, 1024, step): for j in range(0, 1024, step): # i,j 1024x1024 texture coords # x,y spatially corrected for v in r: pk.append([i + v[0], j + v[1]]) x, y = self.corrector.correct((i + v[0]) * 2, (j + v[1]) * 2) # corrected p.append([x, y]) p = numpy.array(p).T pk = numpy.array(pk).T omega = float(self.imageobj.header['Omega']) self.pars['distance'] = float(self.pars['distance']) * 1000 tth, eta = transform.compute_tth_eta(p, **self.pars) gve = transform.compute_g_vectors(tth, eta, omega * self.pars['omegasign'], self.pars['wavelength']) self.pts = [] print "Setting up image mapping", p.shape, gve.shape for i in range(pk.shape[1]): self.pts.append([ pk[1, i] / 1024., pk[0, i] / 1024., gve[0, i], gve[1, i], gve[2, i] ]) #for p in self.pts: # print p self.setupTexture()
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 calccolumns(p, c, g, pks=None): """ p = parameters c = columnfile g = grain pks = selection of which peaks to use for the grain. If none we do all. """ t = g.translation p.set('t_x', t[0]) p.set('t_y', t[1]) p.set('t_z', t[2]) # tth, eta of the spots given this origin position if pks is None: pks = ~np.isnan(c.sc) tth, eta = transform.compute_tth_eta([c.sc[pks], c.fc[pks]], omega=c.omega[pks], **p.parameters) # g-vectors given this origin gve = transform.compute_g_vectors(tth, eta, c.omega[pks], p.get("wavelength"), p.get("wedge"), p.get("chi")) # Find hkl indices hklo = np.dot(g.ubi, gve) hkli = np.round(hklo) diff = hklo - hkli # Now uncompute to get ideal spot positions in each case: gcalc = np.dot(g.ub, hkli) tthcalc, etacalc, omegacalc = transform.uncompute_g_vectors( gcalc, p.get("wavelength"), p.get("wedge"), p.get("chi")) # which eta to choose - there are two possibilities # ... eta should always be in -180, 180 as it is arctan2 smatch = np.sign(eta) == np.sign(etacalc[0]) etachosen = np.where(smatch, etacalc[0], etacalc[1]) omegachosen = np.where(smatch, omegacalc[0], omegacalc[1]) # deal with the mod360 for omega omegachosen = mod360(omegachosen, c.omega[pks]) fcc, scc = transform.compute_xyz_from_tth_eta(tthcalc, etachosen, omegachosen, **p.parameters) # how close to reciprocal lattice point (could throw out some peaks here...) drlv = np.sqrt((diff * diff).sum(axis=0)) # save arrays to colfile: c.drlv[pks] = drlv c.tth_per_grain[pks] = tth c.eta_per_grain[pks] = eta c.tthcalc[pks] = tthcalc c.etacalc[pks] = etachosen c.omegacalc[pks] = omegachosen c.sccalc[pks] = scc c.fccalc[pks] = fcc return c
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 test_0_0_0(self): """ wedge, chi = 0 """ SANITY = False om = np.zeros(self.np, np.float) g_old = transform.compute_g_vectors(self.tth, self.eta, om, self.wvln, wedge=0.0, chi=0.0) if SANITY: print g_old.shape, g_old[:, 0] k = transform.compute_k_vectors(self.tth, self.eta, self.wvln) if SANITY: print "k=", k[:, 0] g_new = gv_general.k_to_g(k, om) if SANITY: print g_new.shape, g_new[:, 0] if SANITY: print "end routine" self.assertAlmostEqual(array_diff(g_new, g_old), 0, 6)
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 update_cols_per_grain(self, flt, pars, OMSLOP, grains, x, y): """ update the twotheta, eta, g-vector columns to be sure they are right fill in some weighting estimates for fitting """ # Fill flt columns by iterating over the grains for i, gr in enumerate(grains): peak_pos = [flt.sc[gr.mask], flt.fc[gr.mask]] omega = flt.omega[gr.mask] pars.parameters['t_x'] = np.ones(np.sum( gr.mask)) * x[i] #origin[0] pars.parameters['t_y'] = np.ones(np.sum( gr.mask)) * y[i] #0 #origin[1] pars.parameters['t_z'] = np.zeros(np.sum(gr.mask)) tth, eta = scanning_transform.compute_tth_eta(peak_pos, omega=omega, **pars.parameters) gve = transform.compute_g_vectors(tth, eta, omega, pars.get('wavelength'), wedge=pars.get('wedge'), chi=pars.get('chi')) pars.parameters['t_x'] = 0 pars.parameters['t_y'] = 0 pars.parameters['t_z'] = 0 flt.tth[gr.mask] = tth flt.eta[gr.mask] = eta if flt.wtth.any(): # Compute the relative tth, eta, omega errors ... wtth, weta, womega = self.grain_fitter.estimate_weights( pars, flt, OMSLOP, gr) flt.wtth[gr.mask] = wtth flt.weta[gr.mask] = weta flt.womega[gr.mask] = womega flt.gx[gr.mask] = gve[0] flt.gy[gr.mask] = gve[1] flt.gz[gr.mask] = gve[2] return flt.tth, flt.eta, np.array([flt.gx, flt.gy, flt.gz])
def test_0_0(self): """ wedge, chi = 0 """ SANITY = False if SANITY: print("*" * 80) om = np.zeros(self.np, np.float) g_old = transform.compute_g_vectors(self.tth, self.eta, self.omega, self.wvln, wedge=0.0, chi=0.0) if SANITY: print(g_old.shape, g_old[:, :3]) k = transform.compute_k_vectors(self.tth, self.eta, self.wvln) if SANITY: print("k=", k[:, :3]) g_new = gv_general.k_to_g(k, self.omega, axis=[0, 0, -1]) if SANITY: print(g_new.shape, g_new[:, :3]) if SANITY: print("end routine") if SANITY: print("*" * 80) self.assertAlmostEqual(array_diff(g_new, g_old), 0, 6)
def test_25_30(self): """ wedge, chi = 25,30 """ w, c = 25, 30 SANITY = False if SANITY: print "*" * 80 om = np.zeros(self.np, np.float) g_old = transform.compute_g_vectors(self.tth, self.eta, self.omega, self.wvln, wedge=w, chi=c) if SANITY: print g_old.shape, "\n", g_old[:, :3] k = transform.compute_k_vectors(self.tth, self.eta, self.wvln) if SANITY: print "k=", k[:, :3] post = gv_general.chiwedge(chi=c, wedge=w) g_new = gv_general.k_to_g(k, self.omega, axis=[0, 0, -1], post=post) if SANITY: print g_new.shape, g_new[:, :3] if SANITY: print "end routine" if SANITY: print "*" * 80 self.assertAlmostEqual(array_diff(g_new, g_old), 0, 6)
def update_cols( flt, pars, OMSLOP ): """ update the twotheta, eta, g-vector columns to be sure they are right fill in some weighting estimates for fitting """ tth, eta = transform.compute_tth_eta( [flt.sc, flt.fc], **pars.parameters ) gve = transform.compute_g_vectors( tth, eta, flt.omega, pars.get('wavelength'), wedge=pars.get('wedge'), chi=pars.get('chi') ) flt.addcolumn( tth , "tth" ) flt.addcolumn( eta , "eta" ) # Compute the relative tth, eta, omega errors ... wtth, weta, womega = estimate_weights( pars, flt, OMSLOP ) flt.addcolumn( wtth, "wtth" ) flt.addcolumn( weta, "weta" ) flt.addcolumn( womega, "womega" ) flt.addcolumn( gve[0], "gx" ) flt.addcolumn( gve[1], "gy" ) flt.addcolumn( gve[2], "gz" ) return tth, eta, gve
def computegv(self): """ Using tth, eta and omega angles, compute x,y,z of spot in reciprocal space """ if "tth" not in self.colfile.titles: self.compute_tth_eta() pars = self.parameterobj.get_parameters() if "omegasign" in pars: om_sgn = pars["omegasign"] else: om_sgn = 1.0 gv = transform.compute_g_vectors(self.getcolumn("tth"), self.getcolumn("eta"), self.getcolumn("omega") * om_sgn, self.parameterobj.get('wavelength'), wedge=self.parameterobj.get('wedge'), chi=self.parameterobj.get('chi')) self.addcolumn(gv[0], "gx") self.addcolumn(gv[1], "gy") self.addcolumn(gv[2], "gz")
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])
assert ((cv-rv)**2).sum()<1e-10,"badness in axis angle" print "AxisAngleOK" testaxisang() def anglediff(a1, a2): return np.arctan2(np.sin(a1-a2), np.cos(a1-a2)) for wedge, chi in [(0.,0.),(-10.,0.), (11,-15), (0,6)]: print "Wedge",wedge,"chi",chi print "gve[0] gve[1] gve[2] om1py om2py om1af om2af omtrue" gve = transform.compute_g_vectors( tth, eta, omega, wvln, wedge, chi ) gve = gve.T.copy() post = gv_general.chiwedge( wedge=wedge, chi=chi ) posti = np.dot(gv_general.wedgemat(wedge), gv_general.chimat(chi)).T # don't try to match this as it is wrong!! # tth, eta, omega = transform.uncompute_g_vectors( hkl.T, wvln, # wedge=wedge, # chi = chi) ppre = np.reshape(pre,(3,3)) ppost = np.reshape(post,(3,3)) omg1, omg2, valid = gv_general.g_to_k( gve.T, wvln, axis=axis, pre=ppre, post=ppost ) #print pre
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 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