diff --git a/ImageD11/grain.py b/ImageD11/grain.py index 8c6442aa..83108c42 100644 --- a/ImageD11/grain.py +++ b/ImageD11/grain.py @@ -77,6 +77,8 @@ def clear_cache(self): self._mt = None self._rmt = None self._unitcell = None + self._ref_unitcell = None + self._orix_orien = None @property def UB(self): @@ -203,6 +205,41 @@ def eps_sample(self, dzero_cell, m=0.5): E = self.eps_sample_matrix(dzero_cell, m) return symm_to_e6(E) + # TODO: we need I/O for this + @property + def ref_unitcell(self): + """The reference (strain-free) unitcell object for this grain""" + if self._ref_unitcell is None: + raise NameError("Reference unitcell not set for this grain!") + else: + return self._ref_unitcell + + @ref_unitcell.setter + def ref_unitcell(self, value): + if not isinstance(value, ImageD11.unitcell.unitcell): + raise TypeError("ref_unitcell must be an ImageD11.unitcell.unitcell instance!") + self._ref_unitcell = value + self._orix_orien = None # must be recomputed because we changed the reference unitcell + + @property + def orix_phase(self): + """The orix phase for the grain, taken straight from the reference unitcell""" + return self.ref_unitcell.orix_phase + + @property + def orix_orien(self): + if self._orix_orien is None: + # get the orix orientation from the reference unit cell + self._orix_orien = self.ref_unitcell.get_orix_orien(self.UB) + return self._orix_orien + + # TODO: classmethod for from_orix_orien to make a grain from an orientation + + def get_ipf_colour(self, axis=np.array([0., 0., 1.])): + """Calls ImageD11.unitcell.unitcell.get_ipf_colour with the grain's UB""" + + return self.ref_unitcell.get_ipf_colour(self.UB, axis) + def to_h5py_group(self, parent_group, group_name): """Creates a H5Py group for this grain. parent_group is the parent H5py Group @@ -217,9 +254,12 @@ def to_h5py_group(self, parent_group, group_name): # optional attributes: for attr in STRINGATTRS + NUMATTRS: - if hasattr(self, attr): - if getattr(self, attr) is not None: - grain_group[attr] = getattr(self, attr) + try: + value = getattr(self, attr) + if value is not None: + grain_group[attr] = value + except (NameError, AttributeError): + continue # write array attributes for attr in ARRATTRS: diff --git a/ImageD11/nbGui/nb_utils.py b/ImageD11/nbGui/nb_utils.py index 336b3a02..f3ec755c 100644 --- a/ImageD11/nbGui/nb_utils.py +++ b/ImageD11/nbGui/nb_utils.py @@ -229,117 +229,8 @@ def save_ubi_map(ds, ubi_map, eps_map, misorientation_map, ipf_x_col_map, ipf_y_ ipfzdset.attrs['CLASS'] = 'IMAGE' -### IPF Colour stuff -# GOTO New file, Orix interface, taking a grain instance (or a U) as an argument -# Check sym_u inside ImageD11 - -def grain_to_rgb(g, ax=(0, 0, 1)): - return hkl_to_color_cubic(crystal_direction_cubic(g.ubi, ax)) - - -def crystal_direction_cubic(ubi, axis): - hkl = np.dot(ubi, axis) - # cubic symmetry implies: - # 24 permutations of h,k,l - # one has abs(h) <= abs(k) <= abs(l) - hkl = abs(hkl) - hkl.sort() - return hkl - - -def hkl_to_color_cubic(hkl): - """ - https://mathematica.stackexchange.com/questions/47492/how-to-create-an-inverse-pole-figure-color-map - [x,y,z]=u⋅[0,0,1]+v⋅[0,1,1]+w⋅[1,1,1]. - These are: - u=z−y, v=y−x, w=x - This triple is used to assign each direction inside the standard triangle - - makeColor[{x_, y_, z_}] := - RGBColor @@ ({z - y, y - x, x}/Max@{z - y, y - x, x}) - """ - x, y, z = hkl - assert x <= y <= z - assert z >= 0 - u, v, w = z - y, y - x, x - m = max(u, v, w) - r, g, b = u / m, v / m, w / m - return (r, g, b) - - -def hkl_to_pf_cubic(hkl): - x, y, z = hkl - assert x <= y <= z - assert z >= 0 - m = np.sqrt((hkl ** 2).sum()) - return x / (z + m), y / (z + m) - - -def get_rgbs_for_grains(grains): - for grain in grains: - grain.rgb_z = grain_to_rgb(grain, ax=(0, 0, 1), ) # symmetry = Symmetry.cubic) - grain.rgb_y = grain_to_rgb(grain, ax=(0, 1, 0), ) # symmetry = Symmetry.cubic) - grain.rgb_x = grain_to_rgb(grain, ax=(1, 0, 0), ) # symmetry = Symmetry.cubic) - - ### Sinogram stuff -# GOTO sinograms/geometry - -def sine_function(x, offset, a, b): - return b * np.sin(np.radians(x)) + a * np.cos(np.radians(x)) + offset - - -def fit_sine_wave(x_data, y_data, initial_guess): - # Fit the sine function to the data - popt, _ = curve_fit(sine_function, x_data, y_data, p0=initial_guess, method='trf', loss='soft_l1', max_nfev=10000) - - offset, a, b = popt - - return offset, a, b - - -def fit_grain_position_from_sino(grain, cf_strong): - initial_guess = (0, 0.5, 0.5) - - offset, a, b = fit_sine_wave(cf_strong.omega[grain.mask_4d], cf_strong.dty[grain.mask_4d], initial_guess) - - grain.cen = offset - - grain.dx = -b - grain.dy = -a - - -def fit_grain_position_from_recon(grain, ds, y0): - grain.bad_recon = False - blobs = blob_log(grain.recon, min_sigma=1, max_sigma=10, num_sigma=10, threshold=.01) - blobs_sorted = sorted(blobs, key=lambda x: x[2], reverse=True) - try: - largest_blob = blobs_sorted[0] - - # we now have the blob position in recon space - # we need to go back to microns - - # first axis (vertical) is x - # second axis (horizontal) is y - - x_recon_space = largest_blob[0] - y_recon_space = largest_blob[1] - - # centre of the recon image is centre of space - - # the below should be independent, tested, inside sinograms/geometry - x_microns = (x_recon_space - grain.recon.shape[0] // 2) * ds.ystep + y0 - y_microns = -(y_recon_space - grain.recon.shape[1] // 2) * ds.ystep + y0 - - grain.x_blob = x_microns - grain.y_blob = y_microns - except IndexError: - # didn't find any blobs - # for small grains like these, if we didn't find a blob, normally indicates recon is bad - # we will exclude it from maps and export - grain.bad_recon = True - # GOTO should be fixed by monitor in assemble_label # should just be a sinogram numpy array and a monitor spectrum @@ -369,6 +260,7 @@ def assign_peaks_to_grains(grains, cf, tol): # add the labels column to the columnfile cf.addcolumn(labels, 'grain_id') + ### Plotting def plot_index_results(ind, colfile, title): @@ -479,31 +371,78 @@ def plot_grain_sinograms(grains, cf, n_grains_to_plot=None): plt.show() -# GOTO follow orix colouring stuff -def triangle(): - """ compute a series of point on the edge of the triangle """ - xy = [np.array(v) for v in ((0, 1, 1), (0, 0, 1), (1, 1, 1))] - xy += [xy[2] * (1 - t) + xy[0] * t for t in np.linspace(0.1, 1, 5)] - return np.array([hkl_to_pf_cubic(np.array(p)) for p in xy]) +def get_rgbs_for_grains(grains): + # get the UB matrices for each grain + UBs = np.array([g.UB for g in grains]) + + # get the reference unit cell of one of the grains (should be the same for all) + ref_ucell = grains[0].ref_unitcell + + # get a meta orientation for all the grains + meta_ori = ref_ucell.get_orix_orien(UBs) + + rgb_x_all = ref_ucell.get_ipf_colour_from_orix_orien(meta_ori, axis=np.array([1., 0, 0])) + rgb_y_all = ref_ucell.get_ipf_colour_from_orix_orien(meta_ori, axis=np.array([0., 1, 0])) + rgb_z_all = ref_ucell.get_ipf_colour_from_orix_orien(meta_ori, axis=np.array([0., 0, 1])) + + for grain, rgb_x, rgb_y, rgb_z in zip(grains, rgb_x_all, rgb_y_all, rgb_z_all): + grain.rgb_x = rgb_x + grain.rgb_y = rgb_y + grain.rgb_z = rgb_z + + +def plot_inverse_pole_figure(grains, axis=np.array([0., 0, 1])): + # get the UB matrices for each grain + UBs = np.array([g.UB for g in grains]) + + # get the reference unit cell of one of the grains (should be the same for all) + ref_ucell = grains[0].ref_unitcell + + # get a meta orientation for all the grains + meta_orien = ref_ucell.get_orix_orien(UBs) + + try: + from orix.vector.vector3d import Vector3d + except ImportError: + raise ImportError("Missing diffpy and/or orix, can't compute orix phase!") + + ipf_direction = Vector3d(axis) + + # get the RGB colours + rgb = ref_ucell.get_ipf_colour_from_orix_orien(meta_orien, axis=ipf_direction) + + # scatter the meta orientation using the colours + meta_orien.scatter("ipf", c=rgb, direction=ipf_direction) + + +def plot_direct_pole_figure(grains, uvw=np.array([1., 0., 0.])): + # get the UB matrices for each grain + UBs = np.array([g.UB for g in grains]) + + # get the reference unit cell of one of the grains (should be the same for all) + ref_ucell = grains[0].ref_unitcell + + # make a combined orientation from them (makes plot much faster) + meta_orien = ref_ucell.get_orix_orien(UBs) + + try: + from orix.vector import Miller + except ImportError: + raise ImportError("Missing orix, can't compute pole figure!") + + # make Miller object from uvw + m1 = Miller(uvw=uvw, phase=ref_ucell.orix_phase).symmetrise(unique=True) + + # get outer product of all orientations with the crystal direction we're interested in + uvw_all = (~meta_orien).outer(m1) + uvw_all.scatter(hemisphere="both", axes_labels=["X", "Y"]) -# GOTO follow orix colouring stuff -def plot_ipfs(grains): - f, a = plt.subplots(1, 3, figsize=(15, 5)) - ty, tx = triangle().T - for i, title in enumerate('xyz'): - ax = np.zeros(3) - ax[i] = 1. - hkl = [crystal_direction_cubic(g.ubi, ax) for g in grains] - xy = np.array([hkl_to_pf_cubic(h) for h in hkl]) - rgb = np.array([hkl_to_color_cubic(h) for h in hkl]) - for j in range(len(grains)): - grains[j].rgb = rgb[j] - a[i].scatter(xy[:, 1], xy[:, 0], - c=rgb) # Note the "x" axis of the plot is the 'k' direction and 'y' is h (smaller) - a[i].set(title=title, aspect='equal', facecolor='silver', xticks=[], yticks=[]) - a[i].plot(tx, ty, 'k-', lw=1) +def plot_all_ipfs(grains): + plot_inverse_pole_figure(grains, axis=np.array([1., 0, 0])) + plot_inverse_pole_figure(grains, axis=np.array([0., 1, 0])) + plot_inverse_pole_figure(grains, axis=np.array([0., 0, 1])) ### Indexing @@ -578,7 +517,8 @@ def refine_grain_positions(cf_3d, ds, grains, parfile, symmetry="cubic", cf_frac hkl_tols=(0.05, 0.025, 0.01)): sample = ds.sample dataset = ds.dset - cf_strong_allrings = select_ring_peaks_by_intensity(cf_3d, frac=cf_frac, dsmax=cf_3d.ds.max(), doplot=None, dstol=cf_dstol) + cf_strong_allrings = select_ring_peaks_by_intensity(cf_3d, frac=cf_frac, dsmax=cf_3d.ds.max(), doplot=None, + dstol=cf_dstol) print("Got {} strong peaks for makemap".format(cf_strong_allrings.nrows)) cf_strong_allrings_path = '{}_{}_3d_peaks_strong_all_rings.flt'.format(sample, dataset) cf_strong_allrings.writefile(cf_strong_allrings_path) diff --git a/ImageD11/sinograms/geometry.py b/ImageD11/sinograms/geometry.py new file mode 100644 index 00000000..3b54f31c --- /dev/null +++ b/ImageD11/sinograms/geometry.py @@ -0,0 +1,115 @@ +"""Sinogram-related geometric functions pulled from various places""" +# TODO: Needs testing/validating! + + +import numpy as np +from scipy.optimize import curve_fit +from skimage.feature import blob_log + + +def dtymask(i, j, cosomega, sinomega, dtyi, step, y0): + """ + Selects the peaks using integer bins in dty. + Needs a UI / plot to see what is happening (map the i,j to the sinogram and recon) + """ + # TODO: Not sure if this is correct (what if sinogram is padded?) + dty_icalc = np.round((step * (i * cosomega + j * sinomega) + y0) / step).astype(int) + return dtyi == dty_icalc + + +def recon_space_to_real_space(i, j, recon_shape, ystep, y0): + """Convert pixel position in reconstruction space (i, j) to real space in microns + i, j are indices to the reconstruction image + recon_shape is a tuple of the shape of the reconstruction array + ystep is the dty step (microns per pixel)""" + x_microns = (i - recon_shape[0] // 2) * ystep + y0 + y_microns = -(j - recon_shape[1] // 2) * ystep + y0 + + return x_microns, y_microns + + +def real_space_to_recon_space(x, y, recon_shape, ystep, y0): + """Convert real space (x, y) position to reconstruction space. + Should be the exact opposite of recon_space_to_real_space() + Accounts for the shape of the reconstruction because the origin in reconstruction space is in the corner of the image.""" + i = recon_shape[0]//2 + (x - y0)/ystep + j = -(recon_shape[1] // 2 + (y - y0)/ystep) + + return i, j + + +def sine_function(omega, offset, a, b): + """Phased sine function with vertical offset using linear combination of sin and cos""" + return b * np.sin(np.radians(omega)) + a * np.cos(np.radians(omega)) + offset + + +def fit_sine_wave(omega, dty, initial_guess): + """Fits a sine wave to omega and dty data + Returns sine wave coefficients and offset + To convert coefficients into lab positions, use sine_coeffs_to_lab_position()""" + popt, _ = curve_fit(sine_function, omega, dty, p0=initial_guess, method='trf', loss='soft_l1', max_nfev=10000) + + offset, a, b = popt + + return offset, a, b + + +def sine_coeffs_to_lab_position(offset, a, b): + """Converts coefficients used in sine_function() to lab coordinates""" + x = -b + y = -a + cen = offset + + return cen, x, y + + +def lab_position_to_sine_coeffs(cen, x, y): + """The opposite of sine_coeffs_to_lab_position""" + b = -x + a = -y + offset = cen + + return offset, a, b + + +def fit_lab_position_from_peaks(omega, dty): + """Fits omega and dty data to a sine wave, converts result into lab coordinates""" + initial_guess = (0, 0.5, 0.5) + + offset, a, b = fit_sine_wave(omega, dty, initial_guess) + + cen, x, y = sine_coeffs_to_lab_position(offset, a, b) + + return cen, x, y + + +def fit_lab_position_from_recon(recon, ystep, y0): + """Fits grain position by doing a LoG search with skimage on the reconstruction image + Useful if grain is very small (close to pointlike) + Returns position in lab frame in microns + Returns None if we couldn't find any blobs""" + blobs = blob_log(recon, min_sigma=1, max_sigma=10, num_sigma=10, threshold=.01) + blobs_sorted = sorted(blobs, key=lambda x: x[2], reverse=True) + try: + largest_blob = blobs_sorted[0] + + # we now have the blob position in recon space + # we need to go back to microns + + # first axis (vertical) is x + # second axis (horizontal) is y + + x_recon_space = largest_blob[0] + y_recon_space = largest_blob[1] + + # centre of the recon image is centre of space + + # the below should be independent, tested, inside sinograms/geometry + + x_microns, y_microns = recon_space_to_real_space(x_recon_space, y_recon_space, recon.shape, ystep, y0) + + return x_microns, y_microns + except IndexError: + # didn't find any blobs + # if we didn't find a blob, normally indicates recon is bad + return None diff --git a/ImageD11/sinograms/point_by_point.py b/ImageD11/sinograms/point_by_point.py index 4d3feb9a..cedd7e58 100755 --- a/ImageD11/sinograms/point_by_point.py +++ b/ImageD11/sinograms/point_by_point.py @@ -20,6 +20,7 @@ from ImageD11 import sym_u, unitcell, parameters import ImageD11.sinograms.dataset import ImageD11.indexing +from ImageD11.sinograms.geometry import dtymask # GOTO - find somewhere! @@ -56,18 +57,6 @@ def hkluniq(ubi, gx, gy, gz, eta, m, tol, hmax): return tcount, ucount -# GOTO Move to geometry -def dtymask(i, j, cosomega, sinomega, dtyi, step, y0): - """ - Selects the peaks using integer bins in dty. - Needs a UI / plot to see what is happening (map the i,j to the sinogram and recon) - """ - dty_icalc = np.round((step * (i * cosomega + j * sinomega) + y0) / step).astype(int) - return dtyi == dty_icalc - - - - def idxpoint( i, j, diff --git a/ImageD11/sinograms/roi_iradon.py b/ImageD11/sinograms/roi_iradon.py index e725918e..5b984d80 100644 --- a/ImageD11/sinograms/roi_iradon.py +++ b/ImageD11/sinograms/roi_iradon.py @@ -340,6 +340,7 @@ def fxyrot(colrow, angle=0, center=0, projection_shifts=None): return colrow + center +# TODO: Validate! @numba.njit(boundscheck=False) def recon_cens(omega, dty, ybins, imsize, wt, y0=0.0): """ Back project the peak centers into a map diff --git a/ImageD11/sinograms/sinogram.py b/ImageD11/sinograms/sinogram.py index 8e604ee6..aa5cd61b 100644 --- a/ImageD11/sinograms/sinogram.py +++ b/ImageD11/sinograms/sinogram.py @@ -11,6 +11,7 @@ import ImageD11.sinograms.dataset import ImageD11.sinograms.properties import ImageD11.sinograms.roi_iradon +import ImageD11.sinograms.geometry class GrainSinogram: @@ -41,6 +42,7 @@ def __init__(self, grain_obj, dataset): self.recon_pad = None self.recon_y0 = None self.recon_niter = None + self.recon_cen = None def prepare_peaks_from_2d(self, cf_2d, grain_label, hkltol=0.25): """Prepare peaks used for sinograms from 2D peaks data @@ -80,7 +82,6 @@ def prepare_peaks_from_2d(self, cf_2d, grain_label, hkltol=0.25): self.cf_for_sino = grain_flt - def prepare_peaks_from_4d(self, cf_4d, grain_label, hkltol=0.25): """Prepares peaks used for sinograms from 4D peaks data. cf_4d should contain grain assignments @@ -155,6 +156,26 @@ def build_sinogram(self): self.sinoangles = sinoangles[order] self.ssino = self.sino[order].T + def update_lab_position_from_peaks(self, cf_4d, grain_label): + """Updates translation of self.grain using peaks in assigned 4D colfile. + Also updates self.recon_cen with centre""" + mask_4d = cf_4d.grain_id == grain_label + omega = cf_4d.omega[mask_4d] + dty = cf_4d.dty[mask_4d] + cen, x, y = ImageD11.sinograms.geometry.fit_lab_position_from_peaks(omega, dty) + self.grain.translation = np.array([x, y, 0]) + self.recon_cen = cen + + def update_lab_position_from_recon(self, method="iradon"): + """Updates translation of self.grain by finding centre-of-mass of reconstruction + Only really valid for very small grains""" + fitting_result = ImageD11.sinograms.geometry.fit_lab_position_from_recon(self.recons[method], self.ds.ystep, self.recon_y0) + if fitting_result is None: + print("Could not update position as no blob found!") + else: + x, y = fitting_result + self.grain.translation = np.array([x, y, 0]) + def correct_halfmask(self): """Applies halfmask correction to sinogram""" self.ssino = ImageD11.sinograms.roi_iradon.apply_halfmask_to_sino(self.ssino) @@ -163,7 +184,7 @@ def correct_ring_current(self): """Corrects each row of the sinogram to the ring current of the corresponding scan""" self.ssino = self.ssino / self.ds.ring_currents_per_scan_scaled[:, None] - def update_recon_parameters(self, pad=None, y0=None, mask=None, niter=None): + def update_recon_parameters(self, pad=None, y0=None, mask=None, niter=None, cen=None): """Update some or all of the reconstruction parameters in one go""" if pad is not None: @@ -174,6 +195,8 @@ def update_recon_parameters(self, pad=None, y0=None, mask=None, niter=None): self.recon_mask = mask if niter is not None: self.recon_niter = niter + if cen is not None: + self.recon_cen = cen def recon(self, method="iradon", workers=1): """Performs reconstruction given reconstruction method""" @@ -253,7 +276,7 @@ def to_h5py_group(self, parent_group, group_name): recon_par_group = grain_group.require_group("recon_parameters") - for recon_par_attr in ["recon_pad", "recon_y0", "recon_niter"]: + for recon_par_attr in ["recon_pad", "recon_y0", "recon_niter", "recon_cen"]: recon_par_var = getattr(self, recon_par_attr) if recon_par_var is not None: recon_par_group.attrs[recon_par_attr] = recon_par_var @@ -286,7 +309,7 @@ def from_h5py_group(cls, group, ds, grain): setattr(grainsino_obj, sino_attr, sino_var) if "recon_parameters" in group.keys(): - for recon_par_attr in ["recon_pad", "recon_y0", "recon_niter"]: + for recon_par_attr in ["recon_pad", "recon_y0", "recon_niter", "recon_cen"]: recon_par_var = group["recon_parameters"].attrs.get(recon_par_attr)[()] setattr(grainsino_obj, recon_par_attr, recon_par_var) diff --git a/ImageD11/unitcell.py b/ImageD11/unitcell.py index 33c57684..b1c8d73a 100644 --- a/ImageD11/unitcell.py +++ b/ImageD11/unitcell.py @@ -1,5 +1,4 @@ - from __future__ import print_function, division ## Automatically adapted for numpy.oldnumeric Sep 06, 2007 by alter_code1.py @@ -33,33 +32,32 @@ from numpy.linalg import inv from ImageD11 import cImageD11 from xfab import tools, sg - +from scipy.spatial.transform import Rotation as ScipyRotation def radians(x): - return x*math.pi/180. + return x* math.pi / 180. -def degrees(x): - return x*180./math.pi +def degrees(x): + return x * 180. / math.pi -def cross(a,b): +def cross(a, b): """ a x b has length |a||b|sin(theta) """ - return np.array([ a[1]*b[2]-a[2]*b[1] , - a[2]*b[0]-b[2]*a[0] , - a[0]*b[1]-b[0]*a[1] ],float) - + return np.array([a[1] * b[2] - a[2] * b[1], + a[2] * b[0] - b[2] * a[0], + a[0] * b[1] - b[0] * a[1]], float) def norm2(a): """ Compute the unit 2 norm """ - return np.sqrt(np.dot(a,a)) + return np.sqrt(np.dot(a, a)) def unit(a): @@ -67,77 +65,85 @@ def unit(a): Normalise vector a to unit length """ try: - return a/norm2(a) + return a / norm2(a) except: - logging.error("cannot normalise to unit length a=%s"%(str(a))) + logging.error("cannot normalise to unit length a=%s" % (str(a))) raise # Systematic absences -def P(h,k,l): +def P(h, k, l): return False -def A(h,k,l): - return (k+l)%2 != 0 -def B(h,k,l): - return (h+l)%2 != 0 +def A(h, k, l): + return (k + l) % 2 != 0 + + +def B(h, k, l): + return (h + l) % 2 != 0 -def C(h,k,l): - return (h+k)%2 != 0 -def I(h,k,l): - return (h+k+l)%2 != 0 +def C(h, k, l): + return (h + k) % 2 != 0 -def F(h,k,l): - return (h+k)%2!=0 or (h+l)%2!=0 or (k+l)%2!=0 -def R(h,k,l): - return (-h+k+l)%3 != 0 +def I(h, k, l): + return (h + k + l) % 2 != 0 + + +def F(h, k, l): + return (h + k) % 2 != 0 or (h + l) % 2 != 0 or (k + l) % 2 != 0 + + +def R(h, k, l): + return (-h + k + l) % 3 != 0 outif = { - "P" : P , - "A" : I , - "B" : B , - "C" : C , - "I" : I , - "F" : F , - "R" : R} - -def orient_BL( B, h1, h2, g1, g2): + "P": P, + "A": I, + "B": B, + "C": C, + "I": I, + "F": F, + "R": R} + + +def orient_BL(B, h1, h2, g1, g2): """Algorithm was intended to follow this one using 2 indexed reflections. W. R. Busing and H. A. Levy. 457. Acta Cryst. (1967). 22, 457 """ - h1c=np.dot(B,h1) # cartesian H1 - h2c=np.dot(B,h2) # cartesian H2 - t1c=unit(h1c) # unit vector along H1 - t3c=unit(np.cross(h1c,h2c)) - t2c=unit(np.cross(h1c,t3c)) - t1g=unit(g1) - t3g=unit(np.cross(g1,g2)) - t2g=unit(np.cross(g1,t3g)) - T_g = np.transpose(np.array([t1g,t2g,t3g])) # Array are stored by rows and - T_c = np.transpose(np.array([t1c,t2c,t3c])) # these are columns - U=np.dot(T_g , np.linalg.inv(T_c)) - UB=np.dot(U,B) - UBI=np.linalg.inv(UB) + h1c = np.dot(B, h1) # cartesian H1 + h2c = np.dot(B, h2) # cartesian H2 + t1c = unit(h1c) # unit vector along H1 + t3c = unit(np.cross(h1c, h2c)) + t2c = unit(np.cross(h1c, t3c)) + t1g = unit(g1) + t3g = unit(np.cross(g1, g2)) + t2g = unit(np.cross(g1, t3g)) + T_g = np.transpose(np.array([t1g, t2g, t3g])) # Array are stored by rows and + T_c = np.transpose(np.array([t1c, t2c, t3c])) # these are columns + U = np.dot(T_g, np.linalg.inv(T_c)) + UB = np.dot(U, B) + UBI = np.linalg.inv(UB) return UBI, UB + def cosangles_many(ha, hb, gi): """ Finds the cosines of angles between two lists of hkls in reciprocal metric gi """ - assert len(ha[0])==3 and len(hb[0])==3 + assert len(ha[0]) == 3 and len(hb[0]) == 3 na = len(ha) nb = len(hb) hag = np.dot(ha, gi) hbg = np.dot(hb, gi) - hagha = np.sqrt((hag*ha).sum(axis=1)) - hbghb = np.sqrt((hbg*hb).sum(axis=1)) + hagha = np.sqrt((hag * ha).sum(axis=1)) + hbghb = np.sqrt((hbg * hb).sum(axis=1)) haghb = np.dot(ha, hbg.T) - ca = haghb / np.outer( hagha, hbghb ) + ca = haghb / np.outer(hagha, hbghb) assert ca.shape == (na, nb) return ca @@ -152,10 +158,11 @@ def cellfromstring(s): symm = 'P' return unitcell(latt, symm) + class unitcell: # Unit cell stuff # Generate a list of peaks from a unit cell - def __init__(self, lattice_parameters, symmetry = "P", verbose = 0 ): + def __init__(self, lattice_parameters, symmetry="P", verbose=0): """ Unit cell class supply a list (tuple etc) of a,b,c,alpha,beta,gamma @@ -163,110 +170,211 @@ def __init__(self, lattice_parameters, symmetry = "P", verbose = 0 ): or : a space group number (integer) """ self.lattice_parameters = np.array(lattice_parameters) - if self.lattice_parameters.shape[0]!=6: - raise Exception("You must supply 6 lattice parameters\n"+\ + if self.lattice_parameters.shape[0] != 6: + raise Exception("You must supply 6 lattice parameters\n" + \ " a,b,c,alpha,beta,gamma") - self.symmetry = symmetry - if isinstance( symmetry, int ): + + if isinstance(symmetry, int): + # this is an integer spacegroup self.symmetry = symmetry + self.spacegroup = symmetry else: - if self.symmetry not in ["P","A","B","C","I","F","R"]: - raise Exception("Your symmetry "+self.symmetry+\ + + if symmetry not in ["P", "A", "B", "C", "I", "F", "R"]: + raise Exception("Your symmetry " + symmetry + \ " was not recognised") + else: + self.symmetry = symmetry # assigning a function here! self.absent = outif[self.symmetry] + a = self.lattice_parameters[0] b = self.lattice_parameters[1] c = self.lattice_parameters[2] - self.alpha=radians(self.lattice_parameters[3]) - ca= math.cos(radians(self.lattice_parameters[3])) - cb= math.cos(radians(self.lattice_parameters[4])) - cg= math.cos(radians(self.lattice_parameters[5])) - if verbose==1: print("Unit cell",self.lattice_parameters) - self.g = np.array( [[ a*a , a*b*cg, a*c*cb ], - [ a*b*cg , b*b , b*c*ca ], - [ a*c*cb , b*c*ca, c*c ]],float) - if verbose==1: print("Metric tensor\n",self.g) + self.alpha = radians(self.lattice_parameters[3]) + ca = math.cos(radians(self.lattice_parameters[3])) + cb = math.cos(radians(self.lattice_parameters[4])) + cg = math.cos(radians(self.lattice_parameters[5])) + if verbose == 1: print("Unit cell", self.lattice_parameters) + self.g = np.array([[a * a, a * b * cg, a * c * cb], + [a * b * cg, b * b, b * c * ca], + [a * c * cb, b * c * ca, c * c]], float) + if verbose == 1: print("Metric tensor\n", self.g) try: self.gi = inv(self.g) except: - raise Exception("Unit cell was degenerate, could not determine"+\ - "reciprocal metric tensor") - if verbose==1: print("Reciprocal Metric tensor\n",self.gi) - self.astar=np.sqrt(self.gi[0,0]) - self.bstar=np.sqrt(self.gi[1,1]) - self.cstar=np.sqrt(self.gi[2,2]) - - self.alphas=degrees(math.acos(self.gi[1,2]/self.bstar/self.cstar)) - self.betas =degrees(math.acos(self.gi[0,2]/self.astar/self.cstar)) - self.gammas=degrees(math.acos(self.gi[0,1]/self.astar/self.bstar)) - if verbose==1: print("Reciprocal cell") - if verbose==1: + raise Exception("Unit cell was degenerate, could not determine" + \ + "reciprocal metric tensor") + if verbose == 1: print("Reciprocal Metric tensor\n", self.gi) + self.astar = np.sqrt(self.gi[0, 0]) + self.bstar = np.sqrt(self.gi[1, 1]) + self.cstar = np.sqrt(self.gi[2, 2]) + + self.alphas = degrees(math.acos(self.gi[1, 2] / self.bstar / self.cstar)) + self.betas = degrees(math.acos(self.gi[0, 2] / self.astar / self.cstar)) + self.gammas = degrees(math.acos(self.gi[0, 1] / self.astar / self.bstar)) + if verbose == 1: print("Reciprocal cell") + if verbose == 1: print(self.astar, self.bstar, self.cstar, \ - self.alphas, self.betas, self.gammas) + self.alphas, self.betas, self.gammas) # Equation 3 from Busing and Levy - self.B = np.array ( - [ [ self.astar , - self.bstar*math.cos(radians(self.gammas)) , - self.cstar*math.cos(radians(self.betas)) ] , - [ 0 , - self.bstar*math.sin(radians(self.gammas)) , - -self.cstar*math.sin(radians(self.betas))*ca ], - [ 0 , 0 , - 1./c ] ] , float) + self.B = np.array( + [[self.astar, + self.bstar * math.cos(radians(self.gammas)), + self.cstar * math.cos(radians(self.betas))], + [0, + self.bstar * math.sin(radians(self.gammas)), + -self.cstar * math.sin(radians(self.betas)) * ca], + [0, 0, + 1. / c]], float) if verbose == 1: print(self.B) if verbose == 1: - print(np.dot( np.transpose(self.B), - self.B)-self.gi) # this should be zero + print(np.dot(np.transpose(self.B), + self.B) - self.gi) # this should be zero self.hkls = None self.peaks = None self.limit = 0 self.ringtol = 0.001 # used for caching - self.anglehkl_cache = { "ringtol" : self.ringtol , - "B" : self.B, - "BI" : np.linalg.inv(self.B) } + self.anglehkl_cache = {"ringtol": self.ringtol, + "B": self.B, + "BI": np.linalg.inv(self.B)} + + # orix stuff + self._orix_phase = None + + @property + def orix_phase(self): + """Get this unitcell as an Orix Phase object. Useful for pole figures / IPF colours""" + if self._orix_phase is None: + # compute the orix phase + + try: + from orix.quaternion.symmetry import get_point_group + from orix.crystal_map import Phase + from diffpy.structure import Lattice, Structure + except ImportError: + raise ImportError("Missing orix, can't compute orix phase!") + + try: + spacegroup = self.spacegroup + except AttributeError: + raise AttributeError("You must initialise this unitcell with an integer spacegroup symmetry for Orix to work!") + + lattice = Lattice(*tuple(self.lattice_parameters)) + structure = Structure(lattice=lattice) + pg = get_point_group(space_group_number=spacegroup) + phase = Phase(point_group=pg, structure=structure) + self._orix_phase = phase + return self._orix_phase + + def get_orix_orien(self, UBs): + """Get an Orix orientation (containing one or more orientations) + using self.orix_phase from an array of ImageD11 UB matrices""" + try: + from orix.vector import Miller + from orix.quaternion import Orientation + except ImportError: + raise ImportError("Missing orix, can't compute orix orien!") + + phase = self.orix_phase + + m1 = Miller(hkl=[[1, 0, 0], [0, 1, 0], [0, 0, 1]], phase=phase) + + # try to flatten UBs + UBs = np.squeeze(UBs) + + if UBs.shape == (3,3): + # only one UB matrix passed + # this can be directly determined with one call to Orientation.from_align_vectors + ori = Orientation.from_align_vectors(m1, (np.dot(UBs, m1.hkl.T)).T) + return ori + + # the challenge is to quickly determine multiple orientations + + m1_xyz = m1.unit.data + m1_hkl_transpose = m1.hkl.T + # determine all the orientation matrices from align vectors from scipy + matrices = np.zeros_like(UBs) + for inc, UB in enumerate(UBs): + rot, _ = ScipyRotation.align_vectors(m1_xyz, (np.dot(UB, m1_hkl_transpose)).T) + + matrices[inc] = rot.as_matrix() + + # make a final orientation object from all the orientation matrices + # make sure that symmetry is set + final_ori = Orientation.from_matrix(matrices, symmetry=phase.point_group) + + return final_ori + + def get_ipf_colour_from_orix_orien(self, orix_orien, axis=np.array([0., 0., 1.])): + """Gets the TSL IPF colour(s) (Nolze, 2016) in the laboratory frame from an orix orientation + 10.1107/S1600576716012942 + axis is an axis vector in the laboratory frame""" + try: + from orix.vector.vector3d import Vector3d + from orix.plot import IPFColorKeyTSL + except ImportError: + raise ImportError("Missing diffpy and/or orix, can't get IPF colour!") + + ipf_direction = Vector3d(axis) + + ipfkey = IPFColorKeyTSL(self.orix_phase.point_group, direction=ipf_direction) + rgb = ipfkey.orientation2color(orix_orien) + + return rgb + + def get_ipf_colour(self, UBs, axis=np.array([0., 0., 1.])): + """Gets the TSL IPF colour (Nolze, 2016) in the laboratory frame for a list of UB matrices + 10.1107/S1600576716012942 + axis is an axis vector in the laboratory frame + optionally return the orien which is useful for IPF plotting""" + + orien = self.get_orix_orien(UBs) + + rgb = self.get_ipf_colour_from_orix_orien(orien, axis=axis) + + return np.squeeze(rgb) def tostring(self): """ Write out a line containing unit cell information """ - return "%f %f %f %f %f %f %s"%(self.lattice_parameters[0], - self.lattice_parameters[1], - self.lattice_parameters[2], - self.lattice_parameters[3], - self.lattice_parameters[4], - self.lattice_parameters[5], - self.symmetry) - - - def gethkls_xfab(self,dsmax,spg=None): + return "%f %f %f %f %f %f %s" % (self.lattice_parameters[0], + self.lattice_parameters[1], + self.lattice_parameters[2], + self.lattice_parameters[3], + self.lattice_parameters[4], + self.lattice_parameters[5], + self.symmetry) + + def gethkls_xfab(self, dsmax, spg=None): """ Generate hkl list Argument dsmax is the d* limit (eg 1/d) Argument spg is the space group name, e.g. 'R3-c' """ - stl_max = dsmax/2. + stl_max = dsmax / 2. if isinstance(self.symmetry, int): sgnum = self.symmetry else: sgnum = None raw_peaks = tools.genhkl_all(self.lattice_parameters, - 0 , stl_max, - sgname=spg, - sgno = sgnum, - output_stl=True) + 0, stl_max, + sgname=spg, + sgno=sgnum, + output_stl=True) peaks = [] for i in range(len(raw_peaks)): - peaks.append([raw_peaks[i,3]*2, - (int(raw_peaks[i,0]),int(raw_peaks[i,1]),int(raw_peaks[i,2]))]) + peaks.append([raw_peaks[i, 3] * 2, + (int(raw_peaks[i, 0]), int(raw_peaks[i, 1]), int(raw_peaks[i, 2]))]) self.peaks = peaks self.limit = dsmax return peaks - def gethkls(self,dsmax): + def gethkls(self, dsmax): """ Generate hkl list Argument dsmax is the d* limit (eg 1/d) @@ -277,73 +385,72 @@ def gethkls(self,dsmax): if dsmax == self.limit and self.peaks is not None: return self.peaks if isinstance(self.symmetry, int): - return self.gethkls_xfab( dsmax, spg=None ) - h=k=0 - l=1 # skip 0,0,0 - hs=ks=ls=1 - b=0 - peaks=[] - while abs(h)<200: # H - while abs(k)<200: # K - while abs(l)<200: #L - ds=self.ds([h,k,l]) + return self.gethkls_xfab(dsmax, spg=None) + h = k = 0 + l = 1 # skip 0,0,0 + hs = ks = ls = 1 + b = 0 + peaks = [] + while abs(h) < 200: # H + while abs(k) < 200: # K + while abs(l) < 200: # L + ds = self.ds([h, k, l]) if ds < dsmax: - if not self.absent(h,k,l): - peaks.append([ds,(h,k,l)]) + if not self.absent(h, k, l): + peaks.append([ds, (h, k, l)]) else: pass - b=0 + b = 0 else: - if ls==1: - ls=-1 - l=0 + if ls == 1: + ls = -1 + l = 0 else: - ls=1 - l=0 - b=b+1 + ls = 1 + l = 0 + b = b + 1 break - l=l+ls - k=k+ks + l = l + ls + k = k + ks # l is always zero here - if b>1: - if ks==1: - ks=-1 - k=-1 + if b > 1: + if ks == 1: + ks = -1 + k = -1 else: - ks=1 - k=0 - b=b+1 + ks = 1 + k = 0 + b = b + 1 break - h=h+hs - if b>3: - if hs==1: - hs=-1 - h=-1 + h = h + hs + if b > 3: + if hs == 1: + hs = -1 + h = -1 else: - hs=1 - h=0 + hs = 1 + h = 0 break peaks.sort() - self.peaks=peaks - self.limit=dsmax + self.peaks = peaks + self.limit = dsmax return peaks - def ds(self,h): + def ds(self, h): """ computes 1/d for this hkl = hgh """ - return math.sqrt(np.dot(h,np.dot(self.gi,h))) # 1/d or d* - + return math.sqrt(np.dot(h, np.dot(self.gi, h))) # 1/d or d* - def makerings(self,limit,tol=0.001): + def makerings(self, limit, tol=0.001): """ Makes a list of computed powder rings The tolerance is the difference in d* to decide if two peaks overlap """ - self.peaks=self.gethkls(limit+tol) # [ ds, [hkl] ] - self.ringds=[] # a list of floats - self.ringhkls={} # a dict of lists of integer hkl + self.peaks = self.gethkls(limit + tol) # [ ds, [hkl] ] + self.ringds = [] # a list of floats + self.ringhkls = {} # a dict of lists of integer hkl # Append first peak peak = self.peaks[0] self.ringds.append(peak[0]) @@ -353,26 +460,26 @@ def makerings(self,limit,tol=0.001): self.ringhkls[self.ringds[-1]].append(peak[1]) else: self.ringds.append(peak[0]) - self.ringhkls[self.ringds[-1]]= [peak[1]] + self.ringhkls[self.ringds[-1]] = [peak[1]] self.ringtol = tol - def anglehkls(self,h1,h2): + def anglehkls(self, h1, h2): """ Compute the angle between reciprocal lattice vectors h1, h2 """ - g1 = np.dot(h1,np.dot(self.gi,h1)) - g2 = np.dot(h2,np.dot(self.gi,h2)) - g12= np.dot(h1,np.dot(self.gi,h2)) - costheta = g12/math.sqrt(g1*g2) + g1 = np.dot(h1, np.dot(self.gi, h1)) + g2 = np.dot(h2, np.dot(self.gi, h2)) + g12 = np.dot(h1, np.dot(self.gi, h2)) + costheta = g12 / math.sqrt(g1 * g2) try: - return degrees(math.acos(costheta)),costheta + return degrees(math.acos(costheta)), costheta except: - if abs(costheta-1) < 1e-6: - return 0.,1.0 - if abs(costheta+1) < 1e-6: - return 180.,-1.0 + if abs(costheta - 1) < 1e-6: + return 0., 1.0 + if abs(costheta + 1) < 1e-6: + return 180., -1.0 print("Error in unit cell class determining angle") - print("h1",h1,"h2",h2,"Costheta=",costheta) + print("h1", h1, "h2", h2, "Costheta=", costheta) raise def getanglehkls(self, ring1, ring2): @@ -381,25 +488,24 @@ def getanglehkls(self, ring1, ring2): sorted by cos2angle """ if self.ringtol != self.anglehkl_cache['ringtol'] or \ - (self.B != self.anglehkl_cache['B']).any(): - self.anglehkl_cache = {'ringtol':self.ringtol, - 'B':self.B, - 'BI':np.linalg.inv(self.B) } - key = (ring1,ring2) - B = self.anglehkl_cache['B'] + (self.B != self.anglehkl_cache['B']).any(): + self.anglehkl_cache = {'ringtol': self.ringtol, + 'B': self.B, + 'BI': np.linalg.inv(self.B)} + key = (ring1, ring2) + B = self.anglehkl_cache['B'] BI = self.anglehkl_cache['BI'] if key not in self.anglehkl_cache: h1 = self.ringhkls[self.ringds[ring1]] h2 = self.ringhkls[self.ringds[ring2]] - cangs = cosangles_many( h1, h2, self.gi ) - val = filter_pairs( h1, h2, cangs, B, BI ) + cangs = cosangles_many(h1, h2, self.gi) + val = filter_pairs(h1, h2, cangs, B, BI) self.anglehkl_cache[key] = val else: val = self.anglehkl_cache[key] return val - - def orient(self,ring1,g1,ring2,g2,verbose=0, crange = -1.): + def orient(self, ring1, g1, ring2, g2, verbose=0, crange=-1.): """ Compute an orientation matrix using cell parameters and the indexing of two reflections @@ -411,74 +517,76 @@ def orient(self,ring1,g1,ring2,g2,verbose=0, crange = -1.): t2 is in the plane of both (unit vector along g1x(g1xg2)) t3 is perpendicular to both (unit vector along g1xg2) """ - costheta = np.dot( g1, g2 ) / np.sqrt( (g1*g1).sum()*(g2*g2).sum() ) - hab, c2ab, matrs = self.getanglehkls( ring1, ring2 ) + costheta = np.dot(g1, g2) / np.sqrt((g1 * g1).sum() * (g2 * g2).sum()) + hab, c2ab, matrs = self.getanglehkls(ring1, ring2) if crange > 0: - best = np.arange( len(c2ab), dtype=int)[ abs( c2ab - costheta ) < crange ] + best = np.arange(len(c2ab), dtype=int)[abs(c2ab - costheta) < crange] if verbose == 1: print("possible best", best, len(c2ab)) else: - i = np.searchsorted(c2ab, costheta, side='left' ) + i = np.searchsorted(c2ab, costheta, side='left') if i > 0 and (i == len(c2ab) or - (fabs(costheta - c2ab[i-1]) < fabs(costheta - c2ab[i]))): - best = [i-1,] + (fabs(costheta - c2ab[i - 1]) < fabs(costheta - c2ab[i]))): + best = [i - 1, ] else: - best = [i,] - if verbose==1: - print("g1, g2",g1,g2) - print("observed cos2theta",costheta) - print("hab, c2ab",hab,c2ab) - print("best",best) + best = [i, ] + if verbose == 1: + print("g1, g2", g1, g2) + print("observed cos2theta", costheta) + print("hab, c2ab", hab, c2ab) + print("best", best) self.UBIlist = [] - UBlist=[] + UBlist = [] for b in best: h1, h2 = hab[b] - if verbose==1: - print("Assigning h1",h1,g1,self.ds(h1),\ - math.sqrt(np.dot(g1,g1)),\ - self.ds(h1)-math.sqrt(np.dot(g1,g1))) - print("Assigning h2",h2,g2,self.ds(h2),\ - math.sqrt(np.dot(g2,g2)),\ - self.ds(h1)-math.sqrt(np.dot(g1,g1))) - print("Cos angle calc",self.anglehkls(h1,h2), - "obs",costheta,"c2ab",c2ab[b]) + if verbose == 1: + print("Assigning h1", h1, g1, self.ds(h1), \ + math.sqrt(np.dot(g1, g1)), \ + self.ds(h1) - math.sqrt(np.dot(g1, g1))) + print("Assigning h2", h2, g2, self.ds(h2), \ + math.sqrt(np.dot(g2, g2)), \ + self.ds(h1) - math.sqrt(np.dot(g1, g1))) + print("Cos angle calc", self.anglehkls(h1, h2), + "obs", costheta, "c2ab", c2ab[b]) BT = matrs[b] - UBI = np.empty((3,3), float) + UBI = np.empty((3, 3), float) UBI[0] = g1 UBI[1] = g2 - cImageD11.quickorient( UBI, BT ) - if verbose==1: + cImageD11.quickorient(UBI, BT) + if verbose == 1: print("UBI") print(UBI) - h=np.dot(UBI,g1) - print("(%9.3f, %9.3f, %9.3f)"%(h[0],h[1],h[2])) - h=np.dot(UBI,g2) - print("(%9.3f, %9.3f, %9.3f)"%(h[0],h[1],h[2])) - self.UBI=UBI - self.UB=np.linalg.inv(UBI) + h = np.dot(UBI, g1) + print("(%9.3f, %9.3f, %9.3f)" % (h[0], h[1], h[2])) + h = np.dot(UBI, g2) + print("(%9.3f, %9.3f, %9.3f)" % (h[0], h[1], h[2])) + self.UBI = UBI + self.UB = np.linalg.inv(UBI) self.UBIlist.append(UBI) UBlist.append(self.UB) # trim to uniq list? What about small distortions... - self.UBIlist = ubi_equiv( self.UBIlist, UBlist ) + self.UBIlist = ubi_equiv(self.UBIlist, UBlist) + -def BTmat( h1, h2, B, BI ): +def BTmat(h1, h2, B, BI): """ used for computing orientations """ - g1 = np.dot( B, h1 ) # gvectors for these hkl - g2 = np.dot( B, h2 ) - g3 = np.cross( g1, g2 ) - u1 = unit(g1) # normalised + g1 = np.dot(B, h1) # gvectors for these hkl + g2 = np.dot(B, h2) + g3 = np.cross(g1, g2) + u1 = unit(g1) # normalised u3 = unit(g3) u2 = np.cross(u1, u3) - BT = np.dot( BI, np.transpose((u1, u2, u3))) + BT = np.dot(BI, np.transpose((u1, u2, u3))) return BT -HKL0 = np.array( [ [0,0,1,1,-1,1,-1,0, 0, 1, -1, 1, 1, 3, 11], - [0,1,0,1, 1,0, 0,1,-1, 1, 1,-1, 1, 2, 12], - [1,0,0,0, 0,1, 1,1, 1, 1, 1, 1,-1, 1, 13] ], float ) # first unit cell + +HKL0 = np.array([[0, 0, 1, 1, -1, 1, -1, 0, 0, 1, -1, 1, 1, 3, 11], + [0, 1, 0, 1, 1, 0, 0, 1, -1, 1, 1, -1, 1, 2, 12], + [1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, -1, 1, 13]], float) # first unit cell -def filter_pairs( h1, h2, c2a, B, BI, tol = 1e-5): +def filter_pairs(h1, h2, c2a, B, BI, tol=1e-5): """ remove duplicate pairs for orientation searches h1 = reflections of ring1, N1 peaks h2 = reflections of ring2, N2 peaks @@ -487,96 +595,99 @@ def filter_pairs( h1, h2, c2a, B, BI, tol = 1e-5): BI = inverse in real space """ assert c2a.shape == (len(h1), len(h2)) - order = np.argsort( c2a.ravel() ) # increasing in cosine of angle + order = np.argsort(c2a.ravel()) # increasing in cosine of angle c2as = c2a.flat[order] - hi, hj= np.mgrid[0:len(h1),0:len(h2)] + hi, hj = np.mgrid[0:len(h1), 0:len(h2)] hi = hi.ravel()[order] # to get back the peaks hj = hj.ravel()[order] # Results holders: - pairs = [ ] - cangs = [ ] - matrs = [ ] + pairs = [] + cangs = [] + matrs = [] # cluster the cangs assuming a sensible threshold dc = (c2as[1:] - c2as[:-1]) > 1e-8 # differences - inds = list(np.arange( 1, len(dc) + 1, dtype=int )[dc]) + [len(c2as)-1,] - p = 0 # previous + inds = list(np.arange(1, len(dc) + 1, dtype=int)[dc]) + [len(c2as) - 1, ] + p = 0 # previous for i in inds: - c = c2as[p:i] # block is p:i - if abs(c2as[p]) < 0.98: # always keep the first one + c = c2as[p:i] # block is p:i + if abs(c2as[p]) < 0.98: # always keep the first one ha = h1[hi[p]] hb = h2[hj[p]] - pairs.append( (ha, hb) ) - cangs.append( c2as[p] ) - BT = BTmat( ha, hb, B, BI) - matrs.append( BT ) + pairs.append((ha, hb)) + cangs.append(c2as[p]) + BT = BTmat(ha, hb, B, BI) + matrs.append(BT) else: p = i continue if len(c) == 1: p = i continue - assert (c.max()-c.min()) < 2.1e-8, "Angles blocking error in filter_pairs" + assert (c.max() - c.min()) < 2.1e-8, "Angles blocking error in filter_pairs" # here we have a bunch of hkl pairs which all give the same angle # between them. They are not all the same. We generate a pair of peaks # from the first one and see which other pairs index differently - ga = np.dot(B, ha ) - gb = np.dot(B, hb ) - assert abs( np.dot(ga,gb)/np.sqrt(np.dot(ga,ga)*np.dot(gb,gb)) - c2as[p] ) < 2e-8, "mixup in filter_pairs" - gobs = np.array( (ga, gb, (0,0,0)), float) + ga = np.dot(B, ha) + gb = np.dot(B, hb) + assert abs(np.dot(ga, gb) / np.sqrt(np.dot(ga, ga) * np.dot(gb, gb)) - c2as[p]) < 2e-8, "mixup in filter_pairs" + gobs = np.array((ga, gb, (0, 0, 0)), float) UBI = gobs.copy() - cImageD11.quickorient( UBI, BT ) - gtest = [ np.dot( np.linalg.inv(UBI), HKL0 ).T.copy(), ] - for j in range(p+1,i): + cImageD11.quickorient(UBI, BT) + gtest = [np.dot(np.linalg.inv(UBI), HKL0).T.copy(), ] + for j in range(p + 1, i): ha = h1[hi[j]] hb = h2[hj[j]] - BT = BTmat( ha, hb, B, BI) + BT = BTmat(ha, hb, B, BI) newpair = True for gt in gtest: UBI = gobs.copy() - cImageD11.quickorient( UBI, BT ) + cImageD11.quickorient(UBI, BT) npk = cImageD11.score(UBI, gt, 1e-6) if npk == len(HKL0[0]): newpair = False break if newpair: - pairs.append( (ha, hb) ) - cangs.append( c2as[j] ) - matrs.append( BT ) - gtest.append( np.dot( np.linalg.inv(UBI), HKL0 ).T.copy() ) + pairs.append((ha, hb)) + cangs.append(c2as[j]) + matrs.append(BT) + gtest.append(np.dot(np.linalg.inv(UBI), HKL0).T.copy()) p = i return pairs, cangs, matrs -def ubi_equiv( ubilist, ublist, tol=1e-8): + +def ubi_equiv(ubilist, ublist, tol=1e-8): """ Two ubi are considered equivalent if they both index the peaks in the HKL0 array exactly""" if len(ubilist) < 2: return ubilist - order = np.argsort( [np.trace( ubi ) for ubi in ubilist ] ) # low to high - uniq = [ ubilist[ order[-1] ], ] - refgv = [ np.dot( ublist[ order[-1]] , HKL0 ), ] + order = np.argsort([np.trace(ubi) for ubi in ubilist]) # low to high + uniq = [ubilist[order[-1]], ] + refgv = [np.dot(ublist[order[-1]], HKL0), ] for i in order[:-1][::-1]: ubi = ubilist[i] score = 1 - for pks in refgv: # pks is (n,3) for an orientation - hcalc = np.dot( ubi, pks ) - score = min(score, np.abs( np.round( hcalc ) - hcalc).sum() ) - if score <= tol: # matches a previous grain + for pks in refgv: # pks is (n,3) for an orientation + hcalc = np.dot(ubi, pks) + score = min(score, np.abs(np.round(hcalc) - hcalc).sum()) + if score <= tol: # matches a previous grain break - if score > tol: # is a new orientation - uniq.append( ubi ) - refgv.append( np.dot( np.linalg.inv( ubi ) , HKL0 ) ) + if score > tol: # is a new orientation + uniq.append(ubi) + refgv.append(np.dot(np.linalg.inv(ubi), HKL0)) return uniq def unitcell_from_parameters(pars): parnames = "_a _b _c alpha beta gamma".split() - cell = unitcell([pars.get("cell_%s"%(s)) for s in parnames], - pars.get("cell_lattice_[P,A,B,C,I,F,R]")) + cell = unitcell([pars.get("cell_%s" % (s)) for s in parnames], + pars.get("cell_lattice_[P,A,B,C,I,F,R]")) return cell -if __name__=="__main__": - import sys,time - start=time.time() - cell = unitcell([float(x) for x in sys.argv[1:7]],sys.argv[7]) + +if __name__ == "__main__": + import sys, time + + start = time.time() + cell = unitcell([float(x) for x in sys.argv[1:7]], sys.argv[7]) cell.makerings(2) - cell.getanglehkls(11,12) + cell.getanglehkls(11, 12) diff --git a/sandbox/orix/test_pole_figures.ipynb b/sandbox/orix/test_pole_figures.ipynb new file mode 100644 index 00000000..cd4ead6c --- /dev/null +++ b/sandbox/orix/test_pole_figures.ipynb @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "688d07ab-140a-4651-9add-3f91f263e3c9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "sys.path.insert(0, \"/home/esrf/james1997a/Code/ImageD11\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "db7773bf-f438-4dd8-9182-72c0d8694a6c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "from ImageD11.grain import grain\n", + "from ImageD11.unitcell import unitcell\n", + "import numpy as np\n", + "from scipy.spatial.transform import Rotation as R\n", + "\n", + "from orix.quaternion import Orientation, Rotation\n", + "from orix.quaternion.symmetry import get_point_group\n", + "from orix.vector import Miller\n", + "from orix.crystal_map import Phase\n", + "from orix.plot import IPFColorKeyTSL\n", + "from orix.vector.vector3d import Vector3d\n", + "\n", + "from diffpy.structure import Lattice, Structure\n", + "\n", + "from matplotlib import pyplot as plt\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a518262d-452f-405c-ac63-c7b08ce9efdc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "hexagonal_ucell_array = np.array([2.94, 2.94, 4.72, 90, 90, 120])\n", + "hexagonal_ucell = unitcell(hexagonal_ucell_array, symmetry=194)\n", + "B = hexagonal_ucell.B" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d54beae3-f880-4db6-b017-965d307fcfd5", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# make a reference unit cell too\n", + "\n", + "ref_hexagonal_ucell_array = np.array([2.94, 2.94, 4.72, 90, 90, 120])\n", + "ref_hexagonal_ucell = unitcell(ref_hexagonal_ucell_array, symmetry=194)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f870fcba-c1cf-4095-85b1-1c6bceedaa3f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# generate 1000 random orientations\n", + "\n", + "Us = R.random(10000).as_matrix()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e30649b5-4686-48d7-8b19-e98f691c9161", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "UBs = Us @ B" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "644550e2-a7c6-4508-b706-733cc0459e8a", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def plot_inverse_pole_figure(ref_ucell, UBs, axis=np.array([0., 0, 1])):\n", + " # get a meta orientation for all the grains\n", + " meta_orien = ref_ucell.get_orix_orien(UBs)\n", + "\n", + " try:\n", + " from orix.vector.vector3d import Vector3d\n", + " except ImportError:\n", + " raise ImportError(\"Missing diffpy and/or orix, can't compute orix phase!\")\n", + "\n", + " ipf_direction = Vector3d(axis)\n", + "\n", + " # get the RGB colours\n", + " rgb = ref_ucell.get_ipf_colour_from_orix_orien(meta_orien, axis=ipf_direction)\n", + "\n", + " # scatter the meta orientation using the colours\n", + " meta_orien.scatter(\"ipf\", c=rgb, direction=ipf_direction)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9e1c1e36-14c6-4f63-adef-b2d51595b8e1", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_inverse_pole_figure(ref_hexagonal_ucell, UBs)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "c0da7d53-6603-4759-8e33-a791d326467d", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def plot_all_ipfs(ref_ucell, UBs):\n", + " plot_inverse_pole_figure(ref_ucell, UBs, axis=np.array([1., 0, 0]))\n", + " plot_inverse_pole_figure(ref_ucell, UBs, axis=np.array([0., 1, 0]))\n", + " plot_inverse_pole_figure(ref_ucell, UBs, axis=np.array([0., 0, 1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4eb00caf-53f8-4cc8-9f62-1e9cc34bf237", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_all_ipfs(hexagonal_ucell, UBs)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "76860999-ce11-4d2a-a6f1-28a95754e0f2", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# generate 10 orientations clustered near identity\n", + "# they'll all be rotated around x and y such that c* doesn't point exactly || z\n", + "\n", + "Us = R.from_euler(seq='xy', angles=(np.random.random((10, 2))-0.5)*25, degrees=True).as_matrix()\n", + "\n", + "UBs = Us @ B\n", + "\n", + "plot_inverse_pole_figure(hexagonal_ucell, UBs)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "222f3d21-e985-4db9-a1b3-3375a49d3272", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def pf_plot_UBs(ref_ucell, UBs, uvw=np.array([1., 0., 0.])):\n", + " # make a combined orientation from them (makes plot much faster)\n", + " meta_orien = ref_ucell.get_orix_orien(UBs)\n", + " \n", + " # make Miller object from uvw\n", + " m1 = Miller(uvw=uvw, phase=ref_ucell.orix_phase).symmetrise(unique=True)\n", + " \n", + " # get outer product of all orientations with the crystal direction we're interested in\n", + " uvw_all = (~meta_orien).outer(m1)\n", + " \n", + " uvw_all.scatter(hemisphere=\"both\", axes_labels=[\"X\", \"Y\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "04824c35-7b15-4e4f-803b-def5d4313d05", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# let's test a triclinic too:\n", + "\n", + "# Labradorite\n", + "# ICSD 100232\n", + "# 8.1736 12.8736 7.1022 93.462 116.054 90.475\n", + "# space group 2\n", + "triclinic_ucell_array = np.array([8.1736, 12.8736, 7.1022, 93.462, 116.054, 90.475])\n", + "triclinic_ucell = unitcell(triclinic_ucell_array, symmetry=2)\n", + "\n", + "B = triclinic_ucell.B\n", + "\n", + "# establish some orientations that are all close to a* || x\n", + "# we do this by rotating around y and z slightly\n", + "\n", + "Us = R.from_euler(seq='yz', angles=(np.random.random((10000, 2))-0.5)*15, degrees=True).as_matrix()\n", + "\n", + "UBs = Us @ B\n", + "\n", + "# U is identity\n", + "# a* should be along x_lab\n", + "\n", + "uvw = Miller(hkl=(1,0,0),phase=triclinic_ucell.orix_phase).uvw\n", + "\n", + "pf_plot_UBs(triclinic_ucell, UBs, uvw)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (main)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/setup.py b/setup.py index 70f440fc..fe9445a0 100644 --- a/setup.py +++ b/setup.py @@ -167,6 +167,8 @@ def build_extension(self, ext): "scikit-image", "tqdm", 'threadpoolctl ; python_version >= "3" ', + 'orix ; python_version >= "3"', # for orix interface + 'diffpy.structure ; python_version >= "3"' # for orix interface ] diff --git a/test/test_orix.py b/test/test_orix.py new file mode 100644 index 00000000..ec5e913f --- /dev/null +++ b/test/test_orix.py @@ -0,0 +1,268 @@ +import numpy as np +import unittest + +from ImageD11.unitcell import unitcell + +import sys + +if int(sys.version_info.major) == 2: + # we're on Python 2, so skip these tests + raise unittest.SkipTest("Skipping Orix tests on Python 2") +else: + from orix.vector import Miller + from orix.crystal_map import Phase + from scipy.spatial.transform import Rotation as R + + +class TestOrixPhase(unittest.TestCase): + """Tests unitcell.orix_phase""" + + def test_no_spacegroup(self): + # set up hexagonal B matrix without a spacegroup + hex_ucell_array = np.array([3, 3, 4, 90., 90., 120.]) + hex_ucell = unitcell(hex_ucell_array, symmetry='P') + + # should fail because we didn't pass a spacegroup for the symmetry + with self.assertRaises(AttributeError): + phase = hex_ucell.orix_phase + + def test_with_spacegroup(self): + # set up hexagonal B matrix with a spacegroup + hex_ucell_array = np.array([3, 3, 4, 90., 90., 120.]) + hex_ucell = unitcell(hex_ucell_array, symmetry=194) + + # we should have an orix phase object + + self.assertIsInstance(hex_ucell.orix_phase, Phase) + + +class TestGetOrixOrien(unittest.TestCase): + """Tests unitcell.get_orix_orien""" + + def test_no_spacegroup(self): + # set up hexagonal B matrix without a spacegroup + hex_ucell_array = np.array([3, 3, 4.1, 90., 90., 120.]) + hex_ucell = unitcell(hex_ucell_array, symmetry=194) + + B = hex_ucell.B + + # set up reference unit cell + ref_hex_ucell_array = np.array([3, 3, 4.0, 90., 90., 120.]) + ref_hex_ucell = unitcell(ref_hex_ucell_array, symmetry='P') + + U = np.squeeze(R.from_euler('zyx', [-90, 0, -90], degrees=True).as_matrix()) + + UB = np.dot(U, B) + + # should fail because we didn't pass a spacegroup for the symmetry + with self.assertRaises(AttributeError): + ori = ref_hex_ucell.get_orix_orien(UB) + + def test_hexagonal(self): + # set up hexagonal B matrix + hex_ucell_array = np.array([3, 3, 4.1, 90., 90., 120.]) + hex_ucell = unitcell(hex_ucell_array, symmetry=194) + + B = hex_ucell.B + + # set up reference unit cell + ref_hex_ucell_array = np.array([3, 3, 4.0, 90., 90., 120.]) + ref_hex_ucell = unitcell(ref_hex_ucell_array, symmetry=194) + + # set up U matrix + + # we want: + # a* to point in +Z lab + # b* to point in +X lab + # c* to point in +Y lab + + U = np.squeeze(R.from_euler('zyx', [-90, 0, -90], degrees=True).as_matrix()) + + UB = np.dot(U, B) + + orix_phase = ref_hex_ucell.orix_phase + orix_orien = ref_hex_ucell.get_orix_orien(UB) + + # a* should be pointing in lab Z + + # get direction of (100) normal in cartesian lab frame as Numpy array + ra_direc_lab = np.array((~orix_orien * Miller(hkl=(1, 0, 0), phase=orix_phase)).xyz).T + lab_z = np.array([0, 0, 1]) + + ra_direc_lab_unit = ra_direc_lab / np.linalg.norm(ra_direc_lab) + + self.assertTrue(np.allclose(ra_direc_lab_unit, lab_z)) + + def test_hexagonal_many(self): + print("") + # set up hexagonal B matrix + hex_ucell_array = np.array([3, 3, 4.0, 90., 90., 120.]) + hex_ucell = unitcell(hex_ucell_array, symmetry=194) + + B = hex_ucell.B + + # set up reference unit cell + ref_hex_ucell_array = np.array([3, 3, 4.0, 90., 90., 120.]) + ref_hex_ucell = unitcell(ref_hex_ucell_array, symmetry=194) + + # many random orientations + Us = R.random(100000).as_matrix() + + UBs = np.dot(Us, B) + + orix_phase = ref_hex_ucell.orix_phase + orix_orien = ref_hex_ucell.get_orix_orien(UBs) + + # work out a* direction in the lab frame for each orientation + + # get a random vector of a* in reciprocal space + astar = np.array([1, 2, 3]) + # get Miller vector for this + astar_miller = Miller(hkl=astar, phase=orix_phase) + # work out a* directions in lab frame using ImageD11 + astar_lab_id11 = np.dot(UBs, astar) + # work out a* directions in lab frame using Orix + astar_lab_orix = np.array((~orix_orien).outer(astar_miller).xyz).T[0] + + # are they close within 5%? + self.assertTrue(np.allclose(astar_lab_id11, astar_lab_orix, rtol=0.05, atol=0)) + + +class TestIPFCol(unittest.TestCase): + def test_cubic(self): + # set up B matrix + cubic_ucell_array = np.array([3., 3., 3., 90., 90., 90.]) + cubic_ucell = unitcell(cubic_ucell_array, symmetry="F") + + B = cubic_ucell.B + + # set up reference unit cell + ref_cubic_ucell_array = np.array([3, 3, 3, 90., 90., 90.]) + ref_cubic_ucell = unitcell(ref_cubic_ucell_array, symmetry=225) + + # set up U matrix + + # we want: + # a* to point in +Z lab + # b* to point in +X lab + # c* to point in +Y lab + + U = np.squeeze(R.from_euler('zyx', [-90, 0, -90], degrees=True).as_matrix()) + + UB = np.dot(U, B) + + # each of the 100, 010, 001, etc directions should have red colours (cubic symmetry) + + axes = np.array([ + [1., 0, 0], + [0, 1, 0], + [0, 0, 1], + [-1, 0, 0], + [0, -1, 0], + [0, 0, -1] + ]) + + red = np.array([[1., 0., 0.]]) + + for axis in axes: + rgb = ref_cubic_ucell.get_ipf_colour(UBs=UB, axis=axis) + self.assertTrue(np.allclose(rgb, red)) + + def test_cubic_110(self): + cubic_ucell_array = np.array([3., 3., 3., 90., 90., 90.]) + cubic_ucell = unitcell(cubic_ucell_array, symmetry="F") + + B = cubic_ucell.B + + # set up reference unit cell + ref_cubic_ucell_array = np.array([3, 3, 3, 90., 90., 90.]) + ref_cubic_ucell = unitcell(ref_cubic_ucell_array, symmetry=225) + + # set up U matrix + + # we want: + # some (110) normal to point along X + # rotate 45 degrees in Z + # should mean 0.5 e1 + 0.5 e2 + 0.0 e3 + + U = np.squeeze(R.from_euler('z', [44], degrees=True).as_matrix()) + + UB = np.dot(U, B) + + # 110 should be pointing along X + # so in an IPF-X plot, the colour should be green + + rgb = ref_cubic_ucell.get_ipf_colour(UBs=UB, axis=np.array([1, 0, 0])) + green = np.array([0., 1., 0.]) + + self.assertTrue(np.allclose(rgb, green, atol=0.05)) + + def test_cubic_111(self): + # set up B matrix + cubic_ucell_array = np.array([3., 3., 3., 90., 90., 90.]) + cubic_ucell = unitcell(cubic_ucell_array, symmetry="F") + + B = cubic_ucell.B + + # set up reference unit cell + ref_cubic_ucell_array = np.array([3, 3, 3, 90., 90., 90.]) + ref_cubic_ucell = unitcell(ref_cubic_ucell_array, symmetry=225) + + # set up U matrix + + # we want: + # some (111) normal to point along X + # rotate 45 degrees in Z + # should mean 0.5 e1 + 0.5 e2 + 0.0 e3 + + U = np.squeeze(R.from_euler('zy', [45, 45], degrees=True).as_matrix()) + + UB = np.dot(U, B) + + # 111 should be pointing along X + # so in an IPF-X plot, the colour should be blue-ish + + rgb = ref_cubic_ucell.get_ipf_colour(UBs=UB, axis=np.array([1, 0, 0])) + blue = np.array([0., 0., 1.]) + + self.assertTrue(np.allclose(rgb, blue, atol=0.3)) + + def test_hexagonal(self): + # set up hexagonal B matrix + hex_ucell_array = np.array([3, 3, 4, 90., 90., 120.]) + hex_ucell = unitcell(hex_ucell_array, symmetry="P") + + B = hex_ucell.B + + # set up reference unit cell + ref_hex_ucell_array = np.array([3, 3, 4.0, 90., 90., 120.]) + ref_hex_ucell = unitcell(ref_hex_ucell_array, symmetry=194) + + # set up U matrix + + # we want: + # a* to point in +Z lab + # b* to point in +X lab + # c* to point in +Y lab + + U = np.squeeze(R.from_euler('zyx', [-90, 0, -90], degrees=True).as_matrix()) + + UB = np.dot(U, B) + + # on an IPF-Z: + # a* should be parallel to Z + # (100) (10-10) should be along Z + # on TSL, (10-10) is blue + + rgb = ref_hex_ucell.get_ipf_colour(UBs=UB, axis=np.array([0, 0, 1])) + blue = np.array([0., 0., 1.]) + + self.assertTrue(np.allclose(rgb, blue, atol=0.3)) + + # on an IPF-Y, c* should be parallel to Y + # c* is (0001) normal + + rgb = ref_hex_ucell.get_ipf_colour(UBs=UB, axis=np.array([0, 1, 0])) + red = np.array([1., 0., 0.]) + + self.assertTrue(np.allclose(rgb, red, atol=0.3))