Crystallography

Notebook to explore crystallography functions in Anri.

import anri

import urllib.request

struc = anri.crystal.Structure.from_cif("../../../tests/data/cif/Fe.cif")

Now let’s generate some HKLs up to a d-star limit (with a given wavelength):

dsmax = 0.75
wavelength = 0.18
struc.make_hkls(dsmax=dsmax, wavelength=wavelength)

struc.allhkls

Array([[ 1,  0,  0],
       [ 0,  1,  0],
       [ 0,  0,  1],
       [-1,  0,  0],
       [ 0, -1,  0],
       [ 0,  0, -1],
       [ 1,  1,  0],
       [ 0,  1, -1],
       [-1,  1,  0],
       [-1,  0,  1],
       [ 0, -1, -1],
       [ 0,  1,  1],
       [ 1, -1,  0],
       [ 1,  0,  1],
       [ 1,  0, -1],
       [-1, -1,  0],
       [-1,  0, -1],
       [ 0, -1,  1],
       [-1,  1,  1],
       [ 1,  1,  1],
       [ 1,  1, -1],
       [ 1, -1,  1],
       [ 1, -1, -1],
       [-1, -1,  1],
       [-1, -1, -1],
       [-1,  1, -1],
       [ 2,  0,  0],
       [ 0,  0,  2],
       [ 0,  2,  0],
       [ 0, -2,  0],
       [ 0,  0, -2],
       [-2,  0,  0]], dtype=int32)

Because we have a structure with atoms, we can simulate intensities. Calling rings_table will get the intensities for each hkl, and filter out the ones with very low intensity:

struc.rings_table

shape: (18, 7)

h	k	l	tth	ds	intensity	ring_id
i64	i64	i64	f32	f32	f64	u32
1	1	0	5.095967	0.493956	1363.448082	0
0	1	-1	5.095966	0.493956	1363.448082	0
-1	1	0	5.095967	0.493956	1363.448082	0
-1	0	1	5.095967	0.493956	1363.448082	0
0	-1	-1	5.095967	0.493956	1363.448082	0
…	…	…	…	…	…	…
0	0	2	7.209165	0.698559	930.148873	1
0	2	0	7.209165	0.698559	930.148873	1
0	-2	0	7.209165	0.698559	930.148873	1
0	0	-2	7.209165	0.698559	930.148873	1
-2	0	0	7.209165	0.698559	930.148873	1

We can also get a dictionary grouped by ring ID:

struc.rings_dict

{0: shape: (12, 7)
 ┌─────┬─────┬─────┬──────────┬──────────┬─────────────┬─────────┐
 │ h   ┆ k   ┆ l   ┆ tth      ┆ ds       ┆ intensity   ┆ ring_id │
 │ --- ┆ --- ┆ --- ┆ ---      ┆ ---      ┆ ---         ┆ ---     │
 │ i64 ┆ i64 ┆ i64 ┆ f32      ┆ f32      ┆ f64         ┆ u32     │
 ╞═════╪═════╪═════╪══════════╪══════════╪═════════════╪═════════╡
 │ 1   ┆ 1   ┆ 0   ┆ 5.095967 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ 0   ┆ 1   ┆ -1  ┆ 5.095966 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ -1  ┆ 1   ┆ 0   ┆ 5.095967 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ -1  ┆ 0   ┆ 1   ┆ 5.095967 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ 0   ┆ -1  ┆ -1  ┆ 5.095967 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ …   ┆ …   ┆ …   ┆ …        ┆ …        ┆ …           ┆ …       │
 │ 1   ┆ 0   ┆ 1   ┆ 5.095966 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ 1   ┆ 0   ┆ -1  ┆ 5.095967 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ -1  ┆ -1  ┆ 0   ┆ 5.095967 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ -1  ┆ 0   ┆ -1  ┆ 5.095966 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 │ 0   ┆ -1  ┆ 1   ┆ 5.095966 ┆ 0.493956 ┆ 1363.448082 ┆ 0       │
 └─────┴─────┴─────┴──────────┴──────────┴─────────────┴─────────┘,
 1: shape: (6, 7)
 ┌─────┬─────┬─────┬──────────┬──────────┬────────────┬─────────┐
 │ h   ┆ k   ┆ l   ┆ tth      ┆ ds       ┆ intensity  ┆ ring_id │
 │ --- ┆ --- ┆ --- ┆ ---      ┆ ---      ┆ ---        ┆ ---     │
 │ i64 ┆ i64 ┆ i64 ┆ f32      ┆ f32      ┆ f64        ┆ u32     │
 ╞═════╪═════╪═════╪══════════╪══════════╪════════════╪═════════╡
 │ 2   ┆ 0   ┆ 0   ┆ 7.209165 ┆ 0.698559 ┆ 930.148873 ┆ 1       │
 │ 0   ┆ 0   ┆ 2   ┆ 7.209165 ┆ 0.698559 ┆ 930.148873 ┆ 1       │
 │ 0   ┆ 2   ┆ 0   ┆ 7.209165 ┆ 0.698559 ┆ 930.148873 ┆ 1       │
 │ 0   ┆ -2  ┆ 0   ┆ 7.209165 ┆ 0.698559 ┆ 930.148873 ┆ 1       │
 │ 0   ┆ 0   ┆ -2  ┆ 7.209165 ┆ 0.698559 ┆ 930.148873 ┆ 1       │
 │ -2  ┆ 0   ┆ 0   ┆ 7.209165 ┆ 0.698559 ┆ 930.148873 ┆ 1       │
 └─────┴─────┴─────┴──────────┴──────────┴────────────┴─────────┘}

Each entry in the dict is an individual ring, grouped by \(d^*\). This is useful for further indexing procedures etc.

There are some other helpful methods:

struc.ringhkls  # dict, grouped by d-star

{0.4939559996128082: Array([[ 1,  1,  0],
        [ 0,  1, -1],
        [-1,  1,  0],
        [-1,  0,  1],
        [ 0, -1, -1],
        [ 0,  1,  1],
        [ 1, -1,  0],
        [ 1,  0,  1],
        [ 1,  0, -1],
        [-1, -1,  0],
        [-1,  0, -1],
        [ 0, -1,  1]], dtype=int32),
 0.6985592842102051: Array([[ 2,  0,  0],
        [ 0,  0,  2],
        [ 0,  2,  0],
        [ 0, -2,  0],
        [ 0,  0, -2],
        [-2,  0,  0]], dtype=int32)}

struc.ringhkls_arr # just a single array of all hkls with meaningful intensities

Array([[ 1,  1,  0],
       [ 0,  1, -1],
       [-1,  1,  0],
       [-1,  0,  1],
       [ 0, -1, -1],
       [ 0,  1,  1],
       [ 1, -1,  0],
       [ 1,  0,  1],
       [ 1,  0, -1],
       [-1, -1,  0],
       [-1,  0, -1],
       [ 0, -1,  1],
       [ 2,  0,  0],
       [ 0,  0,  2],
       [ 0,  2,  0],
       [ 0, -2,  0],
       [ 0,  0, -2],
       [-2,  0,  0]], dtype=int32)

struc.ringtth  # the unique two-theta values of the rings

Array([5.095967, 7.209165], dtype=float32)

struc.ringds  # the unique d* values of the rings

Array([0.493956 , 0.6985593], dtype=float32)

struc.ringmult  # the multiplicities of the rings

Array([12,  6], dtype=int32)

We can confirm against ImageD11 too:

from ImageD11.unitcell import unitcell
uc = unitcell(struc.lattice_parameters, struc.sgno)
uc

Unitcell | [ 2.8630355  2.8630355  2.8630355 90.        90.        90.       ] | 229

uc.makerings(dsmax, tol=0.0001)

import jax.numpy as jnp
jnp.array(uc.ringds)

Array([0.493956 , 0.6985593], dtype=float32)

(struc.ringds - jnp.array(uc.ringds)).sum()

Array(0., dtype=float32)

uc.ringhkls

{np.float64(0.49395599962805037): [(-1, 0, -1),
  (0, -1, -1),
  (-1, -1, 0),
  (0, 1, -1),
  (-1, 1, 0),
  (1, 0, -1),
  (-1, 0, 1),
  (1, -1, 0),
  (0, -1, 1),
  (1, 1, 0),
  (0, 1, 1),
  (1, 0, 1)],
 np.float64(0.6985592738895483): [(-2, 0, 0),
  (0, -2, 0),
  (0, 0, -2),
  (0, 0, 2),
  (0, 2, 0),
  (2, 0, 0)]}

struc.ringhkls

{0.4939559996128082: Array([[ 1,  1,  0],
        [ 0,  1, -1],
        [-1,  1,  0],
        [-1,  0,  1],
        [ 0, -1, -1],
        [ 0,  1,  1],
        [ 1, -1,  0],
        [ 1,  0,  1],
        [ 1,  0, -1],
        [-1, -1,  0],
        [-1,  0, -1],
        [ 0, -1,  1]], dtype=int32),
 0.6985592842102051: Array([[ 2,  0,  0],
        [ 0,  0,  2],
        [ 0,  2,  0],
        [ 0, -2,  0],
        [ 0,  0, -2],
        [-2,  0,  0]], dtype=int32)}