diff --git a/ImageD11/nbGui/TDXRD/0_segment_frelon.ipynb b/ImageD11/nbGui/TDXRD/0_segment_frelon.ipynb new file mode 100755 index 00000000..4596fbee --- /dev/null +++ b/ImageD11/nbGui/TDXRD/0_segment_frelon.ipynb @@ -0,0 +1,461 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8deabe5b", + "metadata": {}, + "source": [ + "# Jupyter notebook based on ImageD11 to process 3DXRD data\n", + "# Written by Haixing Fang, Jon Wright and James Ball\n", + "## Date: 10/09/2024" + ] + }, + { + "cell_type": "markdown", + "id": "6835a47c-a552-4d1d-b605-1867dd631b2a", + "metadata": {}, + "source": [ + "This notebook will help you to extract the locations of diffraction peaks on your detector images.\n", + "\n", + "It will also merge together your 2D spots (on a stack of detector images with different omega angles).\n", + "\n", + "We merge across omega because we often see the same spot twice on multiple detector images.\n", + "\n", + "The results are saved to the PROCESSED_DATA folder of the experiment, inside the sample and dataset folders that you select within this notebook\n", + "\n", + "## NOTE: These notebooks are under active development\n", + "They require the latest version of ImageD11 from Git to run.\n", + "\n", + "If you don't have this set up yet, you can run the below cell.\n", + "\n", + "It will automatically download and install ImageD11 to your home directory" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2402147c-5513-4907-8ca9-76e3e252df0c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7a943975-9dc1-4b89-af44-4283350def66", + "metadata": { + "tags": [ + "parameters" + ] + }, + "outputs": [], + "source": [ + "# this cell is tagged with 'parameters'\n", + "# to view the tag, select the cell, then find the settings gear icon (right or left sidebar) and look for Cell Tags\n", + "\n", + "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )\n", + "\n", + "# Experts : update these files for your detector if you need to\n", + "\n", + "# give dx/dy as tuple instead of spline\n", + "# Since 2024: there is no good spline for a detector at ID11. You probably want to use an e2dx, e2dy file\n", + "# You can provide this as a simple string:\n", + "# splinefile = '/path/to/spline.spline'\n", + "# or as a tuple of strings for e2dx/e2dy files\n", + "splinefile = ('/data/id11/3dxrd/inhouse/Frelon36/frelon36_spline_20240604_dx.edf','/data/id11/3dxrd/inhouse/Frelon36/frelon36_spline_20240604_dy.edf')\n", + "bgfile = None # 'bg.edf'\n", + "maskfile = '/data/id11/inhouse1/ewoks/detectors/files/Frelon2k_C36/mask.edf'\n", + "\n", + "detector = \"frelon3\" # fixme - guess this from masterfile + scan\n", + "omegamotor = \"diffrz\"\n", + "dtymotor = \"diffty\"\n", + "\n", + "# Default segmentation options\n", + "options = {\n", + " \"bgfile\":bgfile,\n", + " \"maskfile\":maskfile,\n", + " \"threshold\":70,\n", + " \"smoothsigma\":1.0,\n", + " \"bgc\":0.9,\n", + " \"minpx\":3,\n", + " \"m_offset_thresh\":100,\n", + " \"m_ratio_thresh\":150,\n", + "}\n", + "\n", + "# EXPERTS: These can be provided as papermill parameters. Users, leave these as None for now...\n", + "dataroot = None\n", + "analysisroot = None\n", + "sample = None\n", + "dataset = None\n", + "scans = [\"1.1\",]\n", + "\n", + "dset_prefix = \"top_\" # some common string in the names of the datasets if processing multiple scans" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b5c1db6-5a32-4294-abef-cfc2150d24de", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# import functions we need\n", + "\n", + "import glob, pprint\n", + "\n", + "import ImageD11.sinograms.dataset\n", + "import ImageD11.sinograms.lima_segmenter\n", + "import ImageD11.sinograms.assemble_label\n", + "import ImageD11.sinograms.properties\n", + "\n", + "import numpy as np\n", + "import fabio\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import LogNorm\n", + "from skimage import filters, measure, morphology\n", + "import ipywidgets as widgets\n", + "import h5py\n", + "from IPython.display import display\n", + "%matplotlib widget\n", + "\n", + "from ImageD11.nbGui import nb_utils as utils\n", + "from ImageD11.nbGui import segmenter_gui\n", + "\n", + "from ImageD11.frelon_peaksearch import worker, segment_dataset, guess_bg" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5560db3e-720d-440e-954d-6dc313f6c460", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Set up the file paths. Edit this if you are not at ESRF or not using the latest data policy.\n", + "if dataroot is None:\n", + " dataroot, analysisroot = segmenter_gui.guess_ESRF_paths() \n", + "\n", + "if len(dataroot)==0:\n", + " print(\"Please fix in the dataroot and analysisroot folder names above!!\")\n", + "print('dataroot =',repr(dataroot))\n", + "print('analysisroot =',repr(analysisroot))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de77981e-c3bf-4a29-8944-95286831ac34", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# List the samples available:\n", + "segmenter_gui.printsamples(dataroot)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "187950bd-18b5-4bd4-80da-2a0c7a984b11", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# USER: Decide which sample\n", + "if sample is None:\n", + " sample = 'sample'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b2a72fa-ff6d-4e45-89b7-fa64adb62214", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# List the datasets for that sample:\n", + "segmenter_gui.printdatasets( dataroot, sample )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90e2aeb5-8893-4f0f-bf4f-de2c541a83df", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# USER: Decide which dataset\n", + "if dataset is None:\n", + " dataset = \"dataset\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad077c4b-39cc-4b90-9637-33c32f12e364", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# create ImageD11 dataset object\n", + "\n", + "ds = ImageD11.sinograms.dataset.DataSet(dataroot=dataroot,\n", + " analysisroot=analysisroot,\n", + " sample=sample,\n", + " dset=dataset,\n", + " detector=detector,\n", + " omegamotor=omegamotor,\n", + " dtymotor=dtymotor)\n", + "ds.import_all(scans=scans)\n", + "if isinstance(splinefile, (tuple, list)) and len(splinefile) == 1:\n", + " # we have (\"splinefile\", )\n", + " ds.splinefile = splinefile[0] # take the splinefile out of the tuple\n", + "elif isinstance(splinefile, (tuple, list)):\n", + " # we have (e2dx, e2dy)\n", + " ds.e2dxfile, ds.e2dyfile = splinefile\n", + "else:\n", + " # we have \"splinefile\"\n", + " ds.splinefile = splinefile\n", + "ds.maskfile = maskfile\n", + "ds.bgfile = bgfile\n", + "ds.save()\n", + "rawdata_path = ds.dataroot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8822b96c-a33b-4bf2-9d95-e42d6d90e55b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# normally not needed:\n", + "\n", + "# bg = guess_bg( ds )\n", + "# plt.imshow(bg)\n", + "# fabio.edfimage.edfimage(bg).save('bg.edf')\n", + "# plt.colorbar()\n", + "# ds.bgfile = 'bg.edf'" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "051901fc-e8a6-455e-9418-17823c6b222e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "68b22a6a-9325-40f4-af9d-945c0187ffae", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "ui = segmenter_gui.FrelonSegmenterGui(ds, worker, segment_dataset, **options)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eee00548-3a48-44d0-b4ad-e71b71de95ca", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "options = ui.getopts()\n", + "print(options)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a1795a9-16eb-430d-a246-a26b12c35e77", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# now we run the segmenter on all our data\n", + "\n", + "cf_2d, cf_3d = segment_dataset(ds, options)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0fa07e53-93f4-4ce9-b0e5-1da5e6a5d511", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# display some peaks\n", + "f,a=plt.subplots(1,2,figsize=(12,6))\n", + "a[0].plot(cf_3d.f_raw,cf_3d.s_raw,'.',ms=1)\n", + "a[0].set(xlabel='fast index', ylabel='slow index',aspect='equal', title='peaks on detector')\n", + "a[1].plot(cf_3d.omega,cf_3d.sum_intensity,'.',ms=1)\n", + "a[1].set(xlabel='omega',ylabel='sum intensity',yscale='log',title='peaks vs omega');" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "197e8418-030b-4901-8e8f-9f8b1df7c017", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "ImageD11.columnfile.colfile_to_hdf(cf_2d, ds.col2dfile)\n", + "ImageD11.columnfile.colfile_to_hdf(cf_3d, ds.col3dfile)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7085183c-1991-49b3-af09-abe119542166", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "ds.save()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "53e92fd0-8088-4746-b2bb-2735a7cd015e", + "metadata": {}, + "outputs": [], + "source": [ + "# Now that we're happy with our indexing parameters, we can run the below cell to do this in bulk for many samples/datasets\n", + "# by default this will do all samples in sample_list, all datasets with a prefix of dset_prefix\n", + "# you can add samples and datasets to skip in skips_dict\n", + "\n", + "# you can optionally skip samples\n", + "# skips_dict = {\n", + "# \"FeAu_0p5_tR\": [\"ff6\",]\n", + "# }\n", + "# otherwise by default skip nothing:\n", + "skips_dict = {\n", + " ds.sample: []\n", + "}\n", + "\n", + "sample_list = [ds.sample, ]\n", + "\n", + "samples_dict = utils.find_datasets_to_process(rawdata_path, skips_dict, dset_prefix, sample_list)\n", + "\n", + "print(samples_dict)\n", + " \n", + "# manual override:\n", + "# samples_dict = {\"FeAu_0p5_tR_nscope\": [\"top_100um\", \"top_150um\"]}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac6a298f-1405-4d90-b677-7a29c04de67e", + "metadata": {}, + "outputs": [], + "source": [ + "for sample, datasets in samples_dict.items():\n", + " for dataset in datasets:\n", + " print(f\"Processing dataset {dataset} in sample {sample}\")\n", + " print(\"Importing DataSet object\")\n", + " ds = ImageD11.sinograms.dataset.DataSet(dataroot=ds.dataroot,\n", + " analysisroot=ds.analysisroot,\n", + " sample=sample,\n", + " dset=dataset,\n", + " detector=detector,\n", + " omegamotor=omegamotor,\n", + " dtymotor=dtymotor)\n", + " \n", + " if os.path.exists(ds.col2dfile):\n", + " print(f\"Found existing cf_2d for {dataset} in {sample}, skipping\")\n", + " continue\n", + " \n", + " ds.import_all(scans=scans)\n", + " print(f\"I have a DataSet {ds.dset} in sample {ds.sample}\")\n", + " if isinstance(splinefile, (tuple, list)) and len(splinefile) == 1:\n", + " # we have (\"splinefile\", )\n", + " ds.splinefile = splinefile[0] # take the splinefile out of the tuple\n", + " elif isinstance(splinefile, (tuple, list)):\n", + " # we have (e2dx, e2dy)\n", + " ds.e2dxfile, ds.e2dyfile = splinefile\n", + " else:\n", + " # we have \"splinefile\"\n", + " ds.splinefile = splinefile\n", + " \n", + " ds.maskfile = maskfile\n", + " ds.bgfile = bgfile\n", + " ds.save()\n", + " \n", + " print(\"Peaksearching\")\n", + " cf_2d, cf_3d = segment_dataset(ds, options)\n", + " \n", + " print(\"Saving peaks to file\")\n", + " ImageD11.columnfile.colfile_to_hdf(cf_2d, ds.col2dfile)\n", + " ImageD11.columnfile.colfile_to_hdf(cf_3d, ds.col3dfile)\n", + " \n", + " ds.save()\n", + "print('Done!')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab892957-5ce7-4f04-a01c-c04cc9a2715c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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/ImageD11/nbGui/TDXRD/2_3DXRD_index.ipynb b/ImageD11/nbGui/TDXRD/1_index_default.ipynb similarity index 92% rename from ImageD11/nbGui/TDXRD/2_3DXRD_index.ipynb rename to ImageD11/nbGui/TDXRD/1_index_default.ipynb index e9844c87..66661d97 100755 --- a/ImageD11/nbGui/TDXRD/2_3DXRD_index.ipynb +++ b/ImageD11/nbGui/TDXRD/1_index_default.ipynb @@ -24,8 +24,66 @@ }, "outputs": [], "source": [ - "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())\n", - "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )" + "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [ + "parameters" + ] + }, + "outputs": [], + "source": [ + "# this cell is tagged with 'parameters'\n", + "# to view the tag, select the cell, then find the settings gear icon (right or left sidebar) and look for Cell Tags\n", + "\n", + "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )\n", + "\n", + "# desination of H5 files\n", + "# replace below with e.g.:\n", + "# dset_path = '/data/visitor/expt1234/20240101/PROCESSED_DATA/sample/dataset/sample_dataset.h5'\n", + "\n", + "dset_path = ''\n", + "\n", + "phase_str = 'Fe'\n", + "\n", + "# path to parameters .json/.par\n", + "parfile = ''\n", + "\n", + "# peak filtration options\n", + "cf_strong_frac = 0.9837\n", + "cf_strong_dsmax = 1.01\n", + "cf_strong_dstol = 0.01\n", + "\n", + "# indexing options\n", + "indexer_ds_tol = 0.01\n", + "\n", + "# we have to choose which rings we want to generate orientations on\n", + "# generally we want two or three low-multiplicity rings that are isolated from other phases\n", + "# take a look at the ring assignment output from a few cells above, and choose two or three\n", + "rings_for_gen = [0, 1]\n", + "\n", + "# now we want to decide which rings to score our found orientations against\n", + "# generally we can just exclude dodgy rings (close to other phases, only a few peaks in etc)\n", + "rings_for_scoring = [0, 1, 2, 3]\n", + "\n", + "# the sequence of hkl tolerances the indexer will iterate through\n", + "hkl_tols_seq = [0.01, 0.02, 0.03, 0.04]\n", + "# the sequence of minpks fractions the indexer will iterate through\n", + "fracs = [0.9, 0.75]\n", + "# the max number of UBIs we can find per pair of rings\n", + "max_grains = 1000\n", + "\n", + "# makemap parameters\n", + "makemap_hkl_tol_seq = [0.05, 0.025, 0.01]\n", + "symmetry = \"cubic\"\n", + "\n", + "absolute_minpks = 120\n", + "\n", + "dset_prefix = 'ff'" ] }, { @@ -59,21 +117,6 @@ "from ImageD11.peakselect import select_ring_peaks_by_intensity" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# desination of H5 files\n", - "# replace below with e.g.:\n", - "# dset_path = '/data/visitor/expt1234/20240101/PROCESSED_DATA/sample/dataset/sample_dataset.h5'\n", - "\n", - "dset_path = ''" - ] - }, { "cell_type": "code", "execution_count": null, @@ -87,11 +130,24 @@ "ds = ImageD11.sinograms.dataset.load(dset_path)\n", "sample = ds.sample\n", "dataset = ds.dset\n", + "rawdata_path = ds.dataroot\n", + "processed_data_root_dir = ds.analysisroot\n", "\n", "print(ds)\n", "print(ds.shape)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# also set our parameters for indexing\n", + "ds.parfile = parfile\n", + "ds.save()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -111,7 +167,6 @@ "outputs": [], "source": [ "# now let's select a phase to index from our parameters json\n", - "phase_str = 'Fe'\n", "\n", "ucell = ds.phases.unitcells[phase_str]\n", "\n", @@ -175,10 +230,6 @@ "# if the blue line does not look elbow-shaped in the logscale plot, try changing the \"doplot\" parameter (the y scale of the logscale plot) until it does\n", "\n", "\n", - "cf_strong_frac = 0.9837\n", - "cf_strong_dsmax = 1.01\n", - "cf_strong_dstol = 0.01\n", - "\n", "cf_strong = select_ring_peaks_by_intensity(cf_3d, frac=cf_strong_frac, dsmax=cf_strong_dsmax, doplot=0.8, dstol=cf_strong_dstol)\n", "print(f\"Got {cf_strong.nrows} strong peaks for indexing\")\n", "cf_strong_path = f'{sample}_{dataset}_3d_peaks_strong.flt'\n", @@ -246,7 +297,6 @@ "\n", "# USER: set a tolerance in d-space (for assigning peaks to powder rings)\n", "\n", - "indexer_ds_tol = 0.05\n", "indexer.ds_tol = indexer_ds_tol\n", "\n", "# change the log level so we can see what the ring assigments look like\n", @@ -292,23 +342,9 @@ "outputs": [], "source": [ "# now we are indexing!\n", - "# we have to choose which rings we want to generate orientations on\n", - "# generally we want two or three low-multiplicity rings that are isolated from other phases\n", - "# take a look at the ring assignment output from a few cells above, and choose two or three\n", - "rings_for_gen = [0, 1]\n", "\n", - "# now we want to decide which rings to score our found orientations against\n", - "# generally we can just exclude dodgy rings (close to other phases, only a few peaks in etc)\n", - "rings_for_scoring = [0, 1, 2, 3]\n", - "\n", - "# the sequence of hkl tolerances the indexer will iterate through\n", - "hkl_tols_seq = [0.01, 0.02, 0.03, 0.04]\n", - "# the sequence of minpks fractions the indexer will iterate through\n", - "fracs = [0.9, 0.75]\n", "# the tolerance in g-vector angle\n", "cosine_tol = np.cos(np.radians(90 - ds.ostep))\n", - "# the max number of UBIs we can find per pair of rings\n", - "max_grains = 1000\n", "\n", "grains, indexer = utils.do_index(cf=cf_strong,\n", " dstol=indexer.ds_tol,\n", @@ -359,33 +395,9 @@ "tmp_map_path = f'{sample}_{dataset}_grains.map'\n", "\n", "new_flt_path = f'{sample}_{dataset}_3d_peaks_strong_all_rings.flt.new' # flt file containing assignments from makemap\n", - "unindexed_flt_path = f'{sample}_{dataset}_3d_peaks_strong_all_rings.flt.unindexed' # remaining unassigned peaks from makemap" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "ImageD11.grain.write_grain_file(tmp_ubi_path, grains)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "omegas_sorted = np.sort(ds.omega)[0]\n", - "omega_step = np.round(np.diff(omegas_sorted).mean(), 3)\n", - "omega_slop = omega_step/2\n", + "unindexed_flt_path = f'{sample}_{dataset}_3d_peaks_strong_all_rings.flt.unindexed' # remaining unassigned peaks from makemap\n", "\n", - "makemap_hkl_tol_seq = [0.05, 0.025, 0.01]" + "ImageD11.grain.write_grain_file(tmp_ubi_path, grains)" ] }, { @@ -416,7 +428,9 @@ }, "outputs": [], "source": [ - "symmetry = \"cubic\"\n", + "# now run makemap in a loop\n", + "\n", + "omega_slop = ds.ostep/2\n", "\n", "for inc, makemap_tol in enumerate(makemap_hkl_tol_seq):\n", " print(f\"Running makemap {inc+1}/{len(makemap_hkl_tol_seq)}\")\n", @@ -426,6 +440,15 @@ " makemap_output = !makemap.py -p {oldparfile} -u {tmp_map_path} -U {tmp_map_path} -f {cf_strong_allrings_path} -F {unindexed_flt_path} -s {symmetry} -t {makemap_hkl_tol_seq[inc]} --omega_slop={omega_slop} --no_sort" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "utils.plot_grain_histograms(new_flt_path, tmp_map_path, oldparfile, omega_slop, tol=makemap_hkl_tol_seq[-1])" + ] + }, { "cell_type": "code", "execution_count": null, @@ -491,19 +514,11 @@ }, "outputs": [], "source": [ - "# find the spike\n", - "absolute_minpks = 120" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# filter out grains with fewer than 15 peaks\n", + "# filter out grains with fewer than absolute_minpks peaks\n", + "\n", + "# most grains should have a high number of peaks\n", + "# choose absolute_minpks such that the low-peak grains are removed\n", + "\n", "grains_filtered = [grain for grain in grains2 if float(grain.npks) > absolute_minpks]" ] }, @@ -551,6 +566,15 @@ "grains_filtered = ImageD11.grain.read_grain_file(map_path)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "utils.plot_grain_histograms(final_new_flt_path, map_path, oldparfile, omega_slop, tol=makemap_hkl_tol_seq[-1])" + ] + }, { "cell_type": "code", "execution_count": null, @@ -643,37 +667,27 @@ "metadata": {}, "outputs": [], "source": [ - "# change to 0 to allow all cells to be run automatically\n", - "if 1:\n", - " raise ValueError(\"Hello!\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Now that we are happy with our indexing parameters, we can run the below cell to do this in bulk for many samples/datasets\n", + "# Now that we're happy with our indexing parameters, we can run the below cell to do this in bulk for many samples/datasets\n", "# by default this will do all samples in sample_list, all datasets with a prefix of dset_prefix\n", "# you can add samples and datasets to skip in skips_dict\n", "\n", + "# you can optionally skip samples\n", + "# skips_dict = {\n", + "# \"FeAu_0p5_tR\": [\"ff6\",]\n", + "# }\n", + "# otherwise by default skip nothing:\n", "skips_dict = {\n", - " \"FeAu_0p5_tR\": []\n", + " ds.sample: []\n", "}\n", "\n", - "# USER: Change this prefix to match the naming convention of your datasets\n", - "# e.g if your slices are formatted like [\"ff_z0\", \"ff_z1\", \"ff_z2\"] etc, then the prefix could be \"ff\" or \"ff_z\"\n", + "sample_list = [ds.sample, ]\n", "\n", - "dset_prefix = \"ff\"\n", + "samples_dict = utils.find_datasets_to_process(rawdata_path, skips_dict, dset_prefix, sample_list)\n", "\n", - "sample_list = [\"FeAu_0p5_tR\"]\n", - " \n", - "samples_dict = utils.find_datasets_to_process(ds.dataroot, skips_dict, dset_prefix, sample_list)\n", "print(samples_dict)\n", - "\n", - "# manual override example:\n", - "# samples_dict = {\"FeAu_0p5_tR\": [\"ff1\", \"ff2\"]}" + " \n", + "# manual override:\n", + "# samples_dict = {\"FeAu_0p5_tR_nscope\": [\"top_100um\", \"top_150um\"]}" ] }, { @@ -698,7 +712,10 @@ " print(f\"Found existing grains file for {dataset} in {sample}, skipping\")\n", " continue\n", " \n", + " ds.parfile = parfile\n", + " ds.save()\n", " ds.phases = ds.get_phases_from_disk()\n", + " \n", " ucell = ds.phases.unitcells[phase_str]\n", " sample = ds.sample\n", " dataset = ds.dset\n", diff --git a/ImageD11/nbGui/TDXRD/2_3DXRD_index_friedel.ipynb b/ImageD11/nbGui/TDXRD/1_index_friedel.ipynb similarity index 70% rename from ImageD11/nbGui/TDXRD/2_3DXRD_index_friedel.ipynb rename to ImageD11/nbGui/TDXRD/1_index_friedel.ipynb index bebb5426..ed477473 100755 --- a/ImageD11/nbGui/TDXRD/2_3DXRD_index_friedel.ipynb +++ b/ImageD11/nbGui/TDXRD/1_index_friedel.ipynb @@ -6,26 +6,92 @@ "source": [ "# Jupyter notebook based on ImageD11 to process 3DXRD data\n", "# Written by Haixing Fang, Jon Wright and James Ball\n", - "## Date: 27/02/2024" + "## Date: 17/02/2025" ] }, { - "cell_type": "markdown", - "metadata": {}, + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], "source": [ - "Now we have good experimental parameters, we can index more grains!" + "import os\n", + "\n", + "os.environ['OMP_NUM_THREADS'] = '1'\n", + "os.environ['OPENBLAS_NUM_THREADS'] = '1'\n", + "os.environ['MKL_NUM_THREADS'] = '1'\n", + "\n", + "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())" ] }, { "cell_type": "code", "execution_count": null, "metadata": { - "tags": [] + "tags": [ + "parameters" + ] }, "outputs": [], "source": [ - "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())\n", - "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )" + "# this cell is tagged with 'parameters'\n", + "# to view the tag, select the cell, then find the settings gear icon (right or left sidebar) and look for Cell Tags\n", + "\n", + "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )\n", + "\n", + "dset_path = ''\n", + "\n", + "phase_str = 'Fe'\n", + "\n", + "# path to parameters .json/.par\n", + "parfile = ''\n", + "\n", + "# peak filtration options\n", + "cf_strong_frac = 0.991\n", + "cf_strong_dsmax = 1.01\n", + "cf_strong_dstol = 0.01\n", + "\n", + "# friedel pair search options\n", + "womega = 1.0\n", + "weta = 1.0\n", + "wtth = 1.5\n", + "wI = 0.5\n", + "\n", + "# indexing options\n", + "indexer_ds_tol = 0.003\n", + "\n", + "rings_for_gen = [1, 3]\n", + "\n", + "# now we want to decide which rings to score our found orientations against\n", + "# generally we can just exclude dodgy rings (close to other phases, only a few peaks in etc)\n", + "rings_for_scoring = [0, 1, 2, 3]\n", + "\n", + "# the sequence of hkl tolerances the indexer will iterate through\n", + "hkl_tols_seq = [0.01, 0.02]\n", + "# the sequence of minpks fractions the indexer will iterate through\n", + "fracs = [0.9, 0.6]\n", + "\n", + "# the max number of UBIs we can find per pair of rings\n", + "max_grains = 1000\n", + "\n", + "# makemap refinement options\n", + "symmetry = \"cubic\"\n", + "\n", + "gridpars = {\n", + " 'DSTOL' : 0.004,\n", + " 'NUL' : True,\n", + " 'FITPOS' : True,\n", + " 'tolangle' : 0.25,\n", + " 'toldist' : 100.,\n", + " 'NTHREAD' : 1 ,\n", + " 'NPKS': 25\n", + "}\n", + "\n", + "absolute_minpks = 25\n", + "\n", + "dset_prefix = 'ff'" ] }, { @@ -59,22 +125,7 @@ "from ImageD11.sinograms import properties, dataset\n", "\n", "from ImageD11.blobcorrector import eiger_spatial\n", - "from ImageD11.peakselect import select_ring_peaks_by_intensity" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# desination of H5 files\n", - "# replace below with e.g.:\n", - "# dset_path = '/data/visitor/expt1234/20240101/PROCESSED_DATA/sample/dataset/sample_dataset.h5'\n", - "\n", - "dset_path = ''" + "from ImageD11.peakselect import select_ring_peaks_by_intensity, filter_peaks_by_phase" ] }, { @@ -91,10 +142,22 @@ "\n", "sample = ds.sample\n", "dataset = ds.dset\n", + "rawdata_path = ds.dataroot\n", + "processed_data_root_dir = ds.analysisroot\n", "print(ds)\n", "print(ds.shape)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "ds.parfile = parfile\n", + "ds.save()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -114,7 +177,6 @@ "outputs": [], "source": [ "# now let's select a phase to index from our parameters json\n", - "phase_str = 'Fe'\n", "\n", "ucell = ds.phases.unitcells[phase_str]\n", "\n", @@ -180,10 +242,6 @@ "source": [ "# here we are filtering our peaks (cf_3d) to select only the strong peaks from the first ring\n", "\n", - "cf_strong_frac = 0.9837\n", - "cf_strong_dsmax = 0.6\n", - "cf_strong_dstol = 0.01\n", - "\n", "cf_strong = select_ring_peaks_by_intensity(cf_3d, frac=cf_strong_frac, dsmax=cf_strong_dsmax, doplot=0.8, dstol=cf_strong_dstol)\n", "print(f\"Got {cf_strong.nrows} strong peaks for indexing\")" ] @@ -219,18 +277,19 @@ }, "outputs": [], "source": [ + "# compute Lorenz factor\n", "lf = ImageD11.refinegrains.lf(cf_strong.tth, cf_strong.eta)\n", "\n", - "f = plt.figure(figsize=(15,5))\n", + "f = plt.figure(figsize=(15,5), layout='constrained')\n", "ax = f.add_subplot()\n", "\n", "# select peaks between 3 and 5 degrees in omega\n", "om1 = (cf_strong.omega < 5) & (cf_strong.omega > 3)\n", "\n", "# plot omega against intensity for those peaks, coloured by eta (azimuthal position on the ring)\n", - "ax.scatter(cf_strong.omega[om1], np.log10(cf_strong.sum_intensity)[om1], c=cf_strong.eta[om1], marker='o')\n", + "ax.scatter(cf_strong.omega[om1], cf_strong.sum_intensity[om1], c=cf_strong.eta[om1], marker='o')\n", "\n", - "# the friedel pair of these peaks should be 180 degrees away\n", + "# the friedel pair of these peaks should be 180 degrees away in eta\n", "etapair = 180 - cf_strong.eta\n", "\n", "# modulate\n", @@ -240,7 +299,10 @@ "om2 = (cf_strong.omega < 185) & (cf_strong.omega > 183)\n", "\n", "# plot omega against intensity for the friedel pairs as crosses\n", - "ax.scatter(cf_strong.omega[om2] - 180, np.log10(cf_strong.sum_intensity)[om2], c=etapair[om2], marker='+')\n", + "ax.scatter(cf_strong.omega[om2] - 180, cf_strong.sum_intensity[om2], c=etapair[om2], marker='+')\n", + "ax.semilogy()\n", + "\n", + "ax.set(xlabel='omega (deg)', ylabel='peak intensity', title='Coloured by eta')\n", "\n", "# for valid friedel pairs, we should see 'o' and '+' markers close together in omega and intensity, with similar colours (eta)\n", "plt.show()" @@ -263,58 +325,69 @@ " eta = np.degrees(np.arctan2( -dY, dZ ))\n", " return tth, eta\n", "\n", - "def find_friedel_pairs(cf_in, doplot=False):\n", - " womega = 1.5\n", - " weta = 0.2\n", - " wtth = 1.5\n", - " wI = 0.5\n", + "def find_friedel_pairs(cf_in, womega=1.5, weta=0.2, wtth=1.5, wI=0.5, doplot=False):\n", + " # create a 4-dimensional tree\n", + " # dimensions are omega, eta, tth, intensity\n", " t1 = scipy.spatial.cKDTree( np.transpose( [ \n", " womega*(cf_in.omega%360),\n", " weta*(cf_in.eta%360),\n", " wtth*cf_in.tth,\n", " wI*np.log10(cf_in.sum_intensity) ] ))\n", - "\n", + " \n", + " # create another tree for the friedel pair side (omega + 180, 180 - eta)\n", " t2 = scipy.spatial.cKDTree( np.transpose([ \n", " womega*((cf_in.omega+180)%360),\n", " weta*((180-cf_in.eta)%360),\n", " wtth* cf_in.tth,\n", " wI*np.log10(cf_in.sum_intensity) ] ))\n", " \n", + " # create a distance matrix between trees with a max distance of 1, returning a sparse matrix\n", " coo = t1.sparse_distance_matrix( t2, max_distance=1, output_type='coo_matrix' ) # 1 degree eta might be tight?\n", " \n", " inds = np.arange(cf_in.nrows)\n", + " \n", + " # mask for peaks on one side of the friedel pair\n", " p1 = inds[coo.row]\n", + " # mask for peaks on the other side of the friedel pair\n", " p2 = inds[coo.col]\n", " \n", + " # compute tth-eta of friedel pairs\n", " tth, eta = calc_tth_eta( cf_in, p1, p2 )\n", + " # mask for intensity for friedel pairs\n", " s1 = cf_3d.sum_intensity[p1]\n", " s2 = cf_3d.sum_intensity[p2]\n", " \n", + " # convert tth to dstar\n", " dstar = 2*np.sin(np.radians(tth)/2)/cf_in.parameters.get('wavelength')\n", " \n", " if doplot:\n", - " f,a = plt.subplots(2,1,figsize=(20,6))\n", + " f,a = plt.subplots(2,1,figsize=(20,6), layout='constrained', sharex=True)\n", " a[0].hist2d(dstar,eta,bins=(2000,360), norm='log', weights=s1+s2)\n", " a[0].plot(ucell.ringds, np.zeros_like(ucell.ringds),\"|r\",lw=1,ms=90)\n", - " a[0].set(ylabel='eta/deg')\n", - " a[1].hist2d(dstar,coo.data,\n", + " a[0].set(ylabel='eta (deg)')\n", + " a[1].hist2d(dstar,coo.data, # sum of squares of distance matrix\n", " # np.log(s1+s2),\n", " bins=(1000,128), norm='log');\n", " a[1].plot( ucell.ringds, np.full_like(ucell.ringds,4),\"|r\",lw=1,ms=20)\n", " a[1].set(xlabel='dstar', ylabel='distance for search')\n", + " f.suptitle(' Top: D-star vs eta of Friedel pairs \\n Bottom: D-star vs 4D tree distance')\n", " plt.show()\n", " \n", " if doplot:\n", - " f,a = plt.subplots(t1.data.shape[1],1,figsize=(20,6))\n", + " f,a = plt.subplots(t1.data.shape[1],1,figsize=(20,6), layout='constrained', sharex=True)\n", " for i in range(t1.data.shape[1]):\n", " a[i].hist2d(dstar, t1.data[coo.row,i] - t2.data[coo.col,i], bins=(1000,128), norm='log')\n", - " \n", + " a[i].set(ylabel=['Omega', 'Eta', 'Two-theta', 'Log peak intensity'][i])\n", + " f.suptitle('D-star vs error in [omega, eta, tth, intensity] for the friedel pair')\n", + " f.supxlabel('dstar')\n", " plt.show()\n", - " \n", + " \n", + " # Mask to powder rings\n", " m = np.zeros_like(p1, dtype=bool)\n", " for d in ucell.ringds:\n", " m |= abs(dstar - d)<0.002\n", - " \n", + " \n", + " # make columnfiles for each side of the friedel pair\n", " c1 = cf_in.copyrows( p1[m] )\n", " c2 = cf_in.copyrows( p2[m] )\n", " \n", @@ -324,31 +397,40 @@ " c2.ds[:] = dstar[m]\n", " \n", " if doplot:\n", - " fig, ax = plt.subplots()\n", + " fig, ax = plt.subplots(layout='constrained')\n", " ax.plot(c1.eta%360, eta[m]%360,',')\n", + " ax.set(xlabel='eta (deg)', ylabel='eta (deg)', title='Observed vs computed eta for Friedel pairs (c1)')\n", " plt.show()\n", - " \n", + " \n", + " # computed eta values (variable eta) matches c1, so we take c1.eta as eta, then recompute c2.eta\n", " c1.eta[:] = eta[m]\n", " e2 = 180 - eta[m]\n", " c2.eta[:] = np.where( e2 > 180, e2-360, e2)\n", " \n", + " # combine paired peaks into one columnfile\n", " cpair = ImageD11.columnfile.colfile_from_dict({\n", " t: np.concatenate( (c1[t], c2[t]) ) for t in c1.titles } )\n", " cpair.parameters = cf_in.parameters\n", " \n", " if doplot:\n", - " plt.figure()\n", + " plt.figure(figsize=(20,6), layout='constrained')\n", " plt.plot(c1.ds, c1.eta, ',')\n", " plt.plot(c2.ds, c2.eta, ',')\n", " plt.plot(cpair.ds, cpair.eta, ',')\n", + " plt.plot(ucell.ringds, np.full_like(ucell.ringds,4),\"|r\",lw=1,ms=20)\n", + " plt.xlabel('D-star')\n", + " plt.ylabel('Eta')\n", " plt.show()\n", " \n", " cpair.gx[:],cpair.gy[:],cpair.gz[:] = ImageD11.transform.compute_g_vectors( cpair.tth, cpair.eta, cpair.omega, cpair.parameters.get('wavelength') )\n", " \n", " if doplot:\n", - " plt.figure()\n", + " plt.figure(figsize=(20,6), layout='constrained')\n", " plt.plot(cpair.ds, cpair.sum_intensity*np.exp(5*cpair.ds**2),',')\n", " plt.semilogy()\n", + " plt.plot(ucell.ringds, np.full_like(ucell.ringds,4),\"|r\",lw=1,ms=20)\n", + " plt.xlabel('D-star')\n", + " plt.ylabel('Weighted Sum intensity')\n", " plt.show()\n", " \n", " return cpair" @@ -362,120 +444,62 @@ }, "outputs": [], "source": [ - "cf_friedel_pairs = find_friedel_pairs(cf_3d, doplot=False)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# here we are filtering our peaks (cf_3d) to select only the strong peaks from the first ring\n", - "\n", - "cf_friedel_pairs_strong_frac = 0.9837\n", - "cf_friedel_pairs_strong_dsmax = cf_friedel_pairs.ds.max()\n", - "cf_friedel_pairs_strong_dstol = 0.01\n", - "\n", - "cf_friedel_pairs_strong = select_ring_peaks_by_intensity(cf_friedel_pairs, frac=cf_friedel_pairs_strong_frac, dsmax=cf_friedel_pairs_strong_dsmax, doplot=0.8, dstol=cf_friedel_pairs_strong_dstol)\n", - "print(f\"Got {cf_friedel_pairs_strong.nrows} strong peaks for indexing\")\n", - "# cf_strong_path = f'{sample}_{dataset}_3d_peaks_strong.flt'\n", - "# cf_strong.writefile(cf_strong_path)" + "cf_friedel_pairs = find_friedel_pairs(cf_strong, womega=womega, weta=weta, wtth=wtth, wI=wI, doplot=True)" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ - "# specify our ImageD11 indexer with these peaks\n", + "# plot the results\n", "\n", - "indexer = ImageD11.indexing.indexer_from_colfile(cf_friedel_pairs_strong)\n", - "\n", - "print(f\"Indexing {cf_friedel_pairs_strong.nrows} peaks\")\n", - "\n", - "# USER: set a tolerance in d-space (for assigning peaks to powder rings)\n", - "\n", - "indexer_ds_tol = 0.05\n", - "indexer.ds_tol = indexer_ds_tol\n", - "\n", - "# change the log level so we can see what the ring assigments look like\n", - "\n", - "ImageD11.indexing.loglevel = 1\n", - "\n", - "# assign peaks to powder rings\n", - "\n", - "indexer.assigntorings()\n", - "\n", - "# change log level back again\n", - "\n", - "ImageD11.indexing.loglevel = 3" + "fig, ax = plt.subplots(layout='constrained', figsize=(10, 5))\n", + "ax.plot(cf_3d.ds, cf_3d.eta, ',', label='cf_3d')\n", + "ax.plot(cf_friedel_pairs.ds, cf_friedel_pairs.eta, ',', label='cf_friedel_pairs')\n", + "ax.set(xlabel='d-star', ylabel='eta')\n", + "ax.legend()\n", + "plt.show()" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ - "# let's plot the assigned peaks\n", - "\n", - "fig, ax = plt.subplots()\n", - "\n", - "# indexer.ra is the ring assignments\n", - "\n", - "ax.scatter(cf_friedel_pairs_strong.ds, cf_friedel_pairs_strong.eta, c=indexer.ra, cmap='tab20', s=1)\n", - "ax.plot( ucell.ringds, [0,]*len(ucell.ringds), '|', ms=90, c=\"red\")\n", - "ax.set_xlabel(\"d-star\")\n", - "ax.set_ylabel(\"eta\")\n", - "ax.set_xlim(cf_friedel_pairs_strong.ds.min()-0.05, cf_friedel_pairs_strong.ds.max()+0.05)\n", + "# plot the results\n", "\n", + "fig, ax = plt.subplots(layout='constrained', figsize=(10, 5))\n", + "ax.plot(cf_3d.ds, cf_3d.sum_intensity, ',', label='cf_3d')\n", + "ax.plot(cf_friedel_pairs.ds, cf_friedel_pairs.sum_intensity, ',', label='cf_friedel_pairs')\n", + "ax.set(xlabel='d-star', ylabel='sum intensity')\n", + "ax.semilogy()\n", + "ax.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, - "metadata": { - "tags": [] - }, + "metadata": {}, "outputs": [], "source": [ - "# now we are indexing!\n", - "# we have to choose which rings we want to generate orientations on\n", - "# generally we want two or three low-multiplicity rings that are isolated from other phases\n", - "# take a look at the ring assignment output from a few cells above, and choose two or three\n", - "rings_for_gen = [1, 1]\n", + "# Now we index the friedel pair resuls\n", "\n", - "# now we want to decide which rings to score our found orientations against\n", - "# generally we can just exclude dodgy rings (close to other phases, only a few peaks in etc)\n", - "rings_for_scoring = [0, 1, 2, 3, 4, 5, 6, 7, 8]\n", - "\n", - "# the sequence of hkl tolerances the indexer will iterate through\n", - "hkl_tols_seq = [0.01, 0.02, 0.03]\n", - "# the sequence of minpks fractions the indexer will iterate through\n", - "fracs = [0.5]\n", "# the tolerance in g-vector angle\n", "cosine_tol = np.cos(np.radians(90 - ds.ostep))\n", - "# the max number of UBIs we can find per pair of rings\n", - "max_grains = 1000\n", "\n", - "_, indexer = utils.do_index(cf=cf_friedel_pairs_strong,\n", - " dstol=indexer.ds_tol,\n", - " forgen=rings_for_gen,\n", - " foridx=rings_for_scoring,\n", - " hkl_tols=hkl_tols_seq,\n", - " fracs=fracs,\n", - " cosine_tol=cosine_tol,\n", - " max_grains=max_grains,\n", - " unitcell=ucell\n", + "_, indexer = utils.do_index(cf=cf_friedel_pairs,\n", + " dstol=indexer_ds_tol,\n", + " forgen=rings_for_gen,\n", + " foridx=rings_for_scoring,\n", + " hkl_tols=hkl_tols_seq,\n", + " fracs=fracs,\n", + " cosine_tol=cosine_tol,\n", + " max_grains=max_grains,\n", + " unitcell=ucell\n", ")" ] }, @@ -491,9 +515,12 @@ "\n", "indexer.histogram_drlv_fit()\n", "\n", - "plt.figure()\n", + "fig, ax = plt.subplots(layout='constrained', figsize=(10, 5))\n", "for row in indexer.histogram:\n", - " plt.plot(indexer.bins[1:-1], row[:-1],'-')" + " ax.plot(indexer.bins[1:-1], row[:-1],'-')\n", + "\n", + "ax.set(xlabel='Peak error', ylabel='npeaks')\n", + "plt.show()" ] }, { @@ -515,29 +542,23 @@ }, "outputs": [], "source": [ - "omegas_sorted = np.sort(ds.omega)[0]\n", - "omega_step = np.round(np.diff(omegas_sorted).mean(), 3)\n", - "omega_slop = omega_step/2\n", + "nproc = len(os.sched_getaffinity(os.getpid())) - 3\n", "\n", - "gridpars = {\n", - " 'DSTOL' : 0.004,\n", - " 'OMEGAFLOAT' : omega_slop,\n", - " 'COSTOL' : cosine_tol,\n", - " 'NPKS' : 10,\n", - " 'TOLSEQ' : [hkl_tols_seq[-1],],\n", - " 'SYMMETRY' : \"cubic\",\n", - " 'RING1' : [1,5],\n", - " 'RING2' : [1,5],\n", - " 'NUL' : True,\n", - " 'FITPOS' : True,\n", - " 'tolangle' : 0.25,\n", - " 'toldist' : 100.,\n", - " 'NPROC' : None, # guess from cpu_count\n", - " 'NTHREAD' : 1 ,\n", - " }\n", - "\n", - "cf_friedel_pairs_strong.addcolumn(indexer.ga.copy(), 'labels')\n", - "cf_friedel_pairs_strong.addcolumn(np.zeros(cf_friedel_pairs_strong.nrows), 'drlv2')\n", + "omega_slop = ds.ostep/2\n", + "\n", + "gridpars['TOLSEQ'] = [hkl_tols_seq[0],]\n", + "gridpars['COSTOL'] = np.cos(np.radians(90 - ds.ostep))\n", + "gridpars['NPROC'] = nproc\n", + "gridpars['OMEGAFLOAT'] = omega_slop\n", + "gridpars['SYMMETRY'] = symmetry\n", + "gridpars['RING1'] = rings_for_gen\n", + "gridpars['RING2'] = rings_for_gen\n", + "\n", + "# copy out the columnfile used by the indexer\n", + "cf_indexed = indexer.colfile.copy()\n", + "\n", + "cf_indexed.addcolumn(indexer.ga.copy(), 'labels')\n", + "cf_indexed.addcolumn(np.zeros(cf_indexed.nrows), 'drlv2')\n", "\n", "for v in 'xyz':\n", " cf_3d.parameters.stepsizes[f't_{v}'] = 0.1\n", @@ -547,16 +568,15 @@ " grains = [ImageD11.grain.grain(indexer.ubis[i].copy() ),]\n", " # only take indexed spots using Friedel pairs\n", " cfit = ImageD11.columnfile.colfile_from_dict(\n", - " { t:cf_friedel_pairs_strong[t][indexer.ga==i+1] for t in cf_friedel_pairs_strong.titles} )\n", + " { t:cf_indexed[t][indexer.ga==i+1] for t in cf_indexed.titles} )\n", " if cfit.nrows == 0:\n", " continue\n", " fitted = ImageD11.grid_index_parallel.domap( cf_3d.parameters,\n", " cfit,\n", " grains,\n", " gridpars )\n", - " fittedgrains.append( fitted[0] )\n", - " print(fitted[0].ubi)\n", - " print(fitted[0].translation, fitted[0].npks, fitted[0].nuniq )" + " if len(fitted) > 0:\n", + " fittedgrains.append( fitted[0] )" ] }, { @@ -582,22 +602,9 @@ "source": [ "fig, ax = plt.subplots()\n", "ax.hist([float(grain.npks) for grain in fittedgrains], bins=50)\n", - "# ax.semilogy()\n", "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# find the spike\n", - "absolute_minpks = 250" - ] - }, { "cell_type": "code", "execution_count": null, @@ -682,16 +689,36 @@ "source": [ "# run makemap again against all peaks\n", "\n", - "symmetry = \"cubic\"\n", - "\n", "new_filtered_map_path = f'{sample}_{dataset}_nice_grains.map.new'\n", "new_cf_3d_path = cf_3d_path + '.new'\n", "\n", - "final_makemap_tol = 0.01\n", + "final_makemap_tol = hkl_tols_seq[0]\n", "\n", "makemap_output = !makemap.py -p {oldparfile} -u {filtered_map_path} -U {new_filtered_map_path} -f {cf_3d_path} -s {symmetry} -t {final_makemap_tol} --omega_slop={omega_slop} --no_sort" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "grains_final = ImageD11.grain.read_grain_file(new_filtered_map_path)\n", + "\n", + "# 3D scatter plot of grain positions coloured by grain volume\n", + "\n", + "utils.plot_grain_positions(grains_final, colour='npks', centre_plot=False, size_scaling=0.5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "utils.plot_grain_histograms(new_cf_3d_path, new_filtered_map_path, oldparfile, omega_slop, tol=hkl_tols_seq[0])" + ] + }, { "cell_type": "code", "execution_count": null, @@ -700,8 +727,6 @@ }, "outputs": [], "source": [ - "grains_final = ImageD11.grain.read_grain_file(new_filtered_map_path)\n", - "\n", "# import makemap output columnfile with peak assignments\n", "cf_3d = ImageD11.columnfile.columnfile(new_cf_3d_path)\n", "\n", @@ -740,37 +765,27 @@ "metadata": {}, "outputs": [], "source": [ - "# change to 0 to allow all cells to be run automatically\n", - "if 1:\n", - " raise ValueError(\"Hello!\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# Now that we are happy with our indexing parameters, we can run the below cell to do this in bulk for many samples/datasets\n", + "# Now that we're happy with our indexing parameters, we can run the below cell to do this in bulk for many samples/datasets\n", "# by default this will do all samples in sample_list, all datasets with a prefix of dset_prefix\n", "# you can add samples and datasets to skip in skips_dict\n", "\n", + "# you can optionally skip samples\n", + "# skips_dict = {\n", + "# \"FeAu_0p5_tR\": [\"ff6\",]\n", + "# }\n", + "# otherwise by default skip nothing:\n", "skips_dict = {\n", - " \"FeAu_0p5_tR\": []\n", + " ds.sample: []\n", "}\n", "\n", - "# USER: Change this prefix to match the naming convention of your datasets\n", - "# e.g if your slices are formatted like [\"ff_z0\", \"ff_z1\", \"ff_z2\"] etc, then the prefix could be \"ff\" or \"ff_z\"\n", + "sample_list = [ds.sample, ]\n", "\n", - "dset_prefix = \"ff\"\n", + "samples_dict = utils.find_datasets_to_process(rawdata_path, skips_dict, dset_prefix, sample_list)\n", "\n", - "sample_list = [\"FeAu_0p5_tR\"]\n", - " \n", - "samples_dict = utils.find_datasets_to_process(ds.dataroot, skips_dict, dset_prefix, sample_list)\n", "print(samples_dict)\n", - "\n", - "# manual override example:\n", - "# samples_dict = {\"FeAu_0p5_tR\": [\"ff1\", \"ff2\"]}" + " \n", + "# manual override:\n", + "# samples_dict = {\"FeAu_0p5_tR_nscope\": [\"top_100um\", \"top_150um\"]}" ] }, { @@ -799,6 +814,9 @@ " print(f\"Already have grains for {dataset} in sample {sample}, skipping\")\n", " continue\n", " \n", + " ds.parfile = parfile\n", + " ds.save()\n", + " \n", " ds.phases = ds.get_phases_from_disk()\n", " ucell = ds.phases.unitcells[phase_str]\n", " \n", @@ -809,32 +827,35 @@ " cf_3d.writefile(cf_3d_path)\n", " \n", " ucell.makerings(cf_3d.ds.max())\n", + " \n", + " print(\"Filtering to strong peaks\")\n", + " cf_strong = select_ring_peaks_by_intensity(cf_3d, frac=cf_strong_frac, dsmax=cf_strong_dsmax, doplot=False, dstol=cf_strong_dstol)\n", "\n", " print(\"Finding Friedel pairs\")\n", - " cf_friedel_pairs = find_friedel_pairs(cf_3d, doplot=False)\n", - " cf_friedel_pairs_strong_dsmax = cf_friedel_pairs.ds.max()\n", - " cf_friedel_pairs_strong = select_ring_peaks_by_intensity(cf_friedel_pairs, frac=cf_friedel_pairs_strong_frac, dsmax=cf_friedel_pairs_strong_dsmax, dstol=cf_friedel_pairs_strong_dstol)\n", + " cf_friedel_pairs = find_friedel_pairs(cf_strong, womega=womega, weta=weta, wtth=wtth, wI=wI, doplot=False)\n", " \n", " print('Finding orientations from collapsed Friedel pairs')\n", - " _, indexer = utils.do_index(cf=cf_friedel_pairs_strong,\n", - " dstol=indexer.ds_tol,\n", - " forgen=rings_for_gen,\n", - " foridx=rings_for_scoring,\n", - " hkl_tols=hkl_tols_seq,\n", - " fracs=fracs,\n", - " cosine_tol=cosine_tol,\n", - " max_grains=max_grains,\n", - " unitcell=ucell\n", - " )\n", + " cosine_tol = np.cos(np.radians(90 - ds.ostep))\n", + "\n", + " _, indexer = utils.do_index(cf=cf_friedel_pairs,\n", + " dstol=indexer_ds_tol,\n", + " forgen=rings_for_gen,\n", + " foridx=rings_for_scoring,\n", + " hkl_tols=hkl_tols_seq,\n", + " fracs=fracs,\n", + " cosine_tol=cosine_tol,\n", + " max_grains=max_grains,\n", + " unitcell=ucell\n", + " )\n", " \n", " print('Fitting positions of indexed grains')\n", - " omegas_sorted = np.sort(ds.omega)[0]\n", - " omega_step = np.round(np.diff(omegas_sorted).mean(), 3)\n", - " omega_slop = omega_step/2\n", + "\n", + " omega_slop = ds.ostep/2\n", " gridpars['OMEGAFLOAT'] = omega_slop\n", + " cf_indexed = indexer.colfile.copy()\n", " \n", - " cf_friedel_pairs_strong.addcolumn(indexer.ga.copy(), 'labels')\n", - " cf_friedel_pairs_strong.addcolumn(np.zeros(cf_friedel_pairs_strong.nrows), 'drlv2')\n", + " cf_indexed.addcolumn(indexer.ga.copy(), 'labels')\n", + " cf_indexed.addcolumn(np.zeros(cf_indexed.nrows), 'drlv2')\n", "\n", " for v in 'xyz':\n", " cf_3d.parameters.stepsizes[f't_{v}'] = 0.1\n", @@ -843,14 +864,15 @@ " for i in range(len(indexer.ubis)):\n", " grains = [ImageD11.grain.grain(indexer.ubis[i].copy() ),]\n", " cfit = ImageD11.columnfile.colfile_from_dict(\n", - " { t:cf_friedel_pairs_strong[t][indexer.ga==i+1] for t in cf_friedel_pairs_strong.titles} )\n", + " { t:cf_indexed[t][indexer.ga==i+1] for t in cf_indexed.titles} )\n", " if cfit.nrows == 0:\n", " continue\n", " fitted = ImageD11.grid_index_parallel.domap( cf_3d.parameters,\n", " cfit,\n", " grains,\n", " gridpars )\n", - " fittedgrains.append( fitted[0] )\n", + " if len(fitted) > 0:\n", + " fittedgrains.append( fitted[0] )\n", " \n", " grains_filtered = [grain for grain in fittedgrains if float(grain.npks) > absolute_minpks]\n", " filtered_map_path = f'{sample}_{dataset}_nice_grains.map'\n", diff --git a/ImageD11/nbGui/TDXRD/2_3DXRD_index_grid.ipynb b/ImageD11/nbGui/TDXRD/1_index_grid.ipynb similarity index 90% rename from ImageD11/nbGui/TDXRD/2_3DXRD_index_grid.ipynb rename to ImageD11/nbGui/TDXRD/1_index_grid.ipynb index b55aad57..de305b87 100755 --- a/ImageD11/nbGui/TDXRD/2_3DXRD_index_grid.ipynb +++ b/ImageD11/nbGui/TDXRD/1_index_grid.ipynb @@ -1,5 +1,17 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "9f197eab-b00a-415b-857f-78b679c52690", + "metadata": { + "tags": [] + }, + "source": [ + "# Jupyter notebook based on ImageD11 to process 3DXRD data\n", + "# Written by Haixing Fang, Jon Wright and James Ball\n", + "## Date: 17/02/2025" + ] + }, { "cell_type": "code", "execution_count": null, @@ -15,8 +27,75 @@ "os.environ['OPENBLAS_NUM_THREADS'] = '1'\n", "os.environ['MKL_NUM_THREADS'] = '1'\n", "\n", - "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())\n", - "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )" + "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9686b3bc-6618-4a1c-b440-2a8ebc3ab9de", + "metadata": { + "tags": [ + "parameters" + ] + }, + "outputs": [], + "source": [ + "# this cell is tagged with 'parameters'\n", + "# to view the tag, select the cell, then find the settings gear icon (right or left sidebar) and look for Cell Tags\n", + "\n", + "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )\n", + "\n", + "# desination of H5 files\n", + "# replace below with e.g.:\n", + "# dset_path = '/data/visitor/expt1234/20240101/PROCESSED_DATA/sample/dataset/sample_dataset.h5'\n", + "\n", + "dset_path = ''\n", + "\n", + "phase_str = 'Fe'\n", + "\n", + "# path to parameters .json/.par\n", + "parfile = ''\n", + "\n", + "# peak filtration options\n", + "cf_strong_frac = 0.999\n", + "cf_strong_dsmax = 1.017\n", + "cf_strong_dstol = 0.025\n", + "\n", + "cf_strong_allrings_frac = 0.999\n", + "cf_strong_allrings_dstol = 0.025\n", + "\n", + "# indexing options\n", + "indexer_ds_tol = 0.025\n", + "rings_to_use = [0, 1, 3]\n", + "\n", + "# makemap options\n", + "symmetry = \"cubic\"\n", + "makemap_tol_seq = [0.02, 0.015, 0.01]\n", + "\n", + "gridpars = {\n", + " 'DSTOL' : 0.004,\n", + " 'RING1' : [1,0,],\n", + " 'RING2' : [0,],\n", + " 'NUL' : True,\n", + " 'FITPOS' : True,\n", + " 'tolangle' : 0.50,\n", + " 'toldist' : 100.,\n", + " 'NTHREAD' : 1 ,\n", + "}\n", + "\n", + "grid_xlim = 600 # um - extent away from rotation axis to search for grains\n", + "grid_ylim = 600\n", + "grid_zlim = 200\n", + "grid_step = 100 # step size of search grid, um\n", + "\n", + "# fraction of expected number of peaks to accept in Makemap output\n", + "frac = 0.85\n", + "\n", + "# find the spike\n", + "absolute_minpks = 56\n", + "\n", + "dset_prefix = 'ff'" ] }, { @@ -51,22 +130,6 @@ "from ImageD11.peakselect import select_ring_peaks_by_intensity" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "69964e34-6f94-4594-8ff7-1b32c0324a4b", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# desination of H5 files\n", - "# replace below with e.g.:\n", - "# dset_path = '/data/visitor/expt1234/20240101/PROCESSED_DATA/sample/dataset/sample_dataset.h5'\n", - "\n", - "dset_path = ''" - ] - }, { "cell_type": "code", "execution_count": null, @@ -82,11 +145,25 @@ "\n", "sample = ds.sample\n", "dataset = ds.dset\n", + "rawdata_path = ds.dataroot\n", + "processed_data_root_dir = ds.analysisroot\n", "\n", "print(ds)\n", "print(ds.shape)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6bbd76b-aae4-42c6-b850-5165efc651b0", + "metadata": {}, + "outputs": [], + "source": [ + "# also set our parameters for indexing\n", + "ds.parfile = parfile\n", + "ds.save()" + ] + }, { "cell_type": "code", "execution_count": null, @@ -108,7 +185,6 @@ "outputs": [], "source": [ "# now let's select a phase to index from our parameters json\n", - "phase_str = 'Fe'\n", "\n", "ucell = ds.phases.unitcells[phase_str]\n", "\n", @@ -174,11 +250,6 @@ "# this indicates the fractional intensity cutoff we will select\n", "# if the blue line does not look elbow-shaped in the logscale plot, try changing the \"doplot\" parameter (the y scale of the logscale plot) until it does\n", "\n", - "\n", - "cf_strong_frac = 0.999\n", - "cf_strong_dsmax = 1.017\n", - "cf_strong_dstol = 0.025\n", - "\n", "cf_strong = select_ring_peaks_by_intensity(cf_3d, frac=cf_strong_frac, dsmax=cf_strong_dsmax, doplot=0.65, dstol=cf_strong_dstol)\n", "print(f\"Got {cf_strong.nrows} strong peaks for indexing\")" ] @@ -193,9 +264,6 @@ "# we will also export some additional strong peaks across all rings\n", "# this will be useful for grain refinement later (using makemap)\n", "\n", - "cf_strong_allrings_frac = 0.999\n", - "cf_strong_allrings_dstol = 0.025\n", - "\n", "cf_strong_allrings = select_ring_peaks_by_intensity(cf_3d, frac=cf_strong_allrings_frac, dsmax=cf_3d.ds.max(), doplot=0.8, dstol=cf_strong_allrings_dstol)\n", "print(f\"Got {cf_strong_allrings.nrows} strong peaks for makemap\")\n", "cf_strong_allrings_path = f'{sample}_{dataset}_3d_peaks_strong_all_rings.flt'\n", @@ -239,13 +307,11 @@ "source": [ "# specify our ImageD11 indexer with these peaks\n", "\n", - "indexer = ImageD11.indexing.indexer_from_colfile(cf_strong)\n", + "indexer = ImageD11.indexing.indexer_from_colfile_and_ucell(cf_strong, ucell)\n", "\n", "print(f\"Indexing {cf_strong.nrows} peaks\")\n", "\n", "# USER: set a tolerance in d-space (for assigning peaks to powder rings)\n", - "\n", - "indexer_ds_tol = 0.025\n", "indexer.ds_tol = indexer_ds_tol\n", "\n", "# change the log level so we can see what the ring assigments look like\n", @@ -297,8 +363,6 @@ "# now we need to decide which rings to use in the grid index\n", "# typically, 3-4 low multiplicity rings are good\n", "\n", - "rings_to_use = [0, 1, 3]\n", - "\n", "mask = np.zeros(cf_strong.nrows, dtype=bool)\n", "\n", "for ring in rings_to_use:\n", @@ -356,9 +420,7 @@ }, "outputs": [], "source": [ - "omegas_sorted = np.sort(ds.omega)[0]\n", - "omega_step = np.round(np.diff(omegas_sorted).mean(), 3)\n", - "omega_slop = omega_step/2" + "omega_slop = ds.ostep/2" ] }, { @@ -399,7 +461,6 @@ "# choose the fraction of the number of peaks expected - this should be around 0.9 if you had a good clean segementation\n", "# if you suspect you are missing peaks in your data, decrease to around 0.6\n", "\n", - "frac = 0.85\n", "minpeaks = int(np.round(peaks_expected * frac, 2))\n", "minpeaks" ] @@ -448,35 +509,17 @@ "source": [ "from ImageD11.grid_index_parallel import grid_index_parallel\n", "\n", - "symmetry = \"cubic\"\n", + "gridpars['COSTOL'] = np.cos(np.radians(90 - ds.ostep))\n", + "gridpars['NPROC'] = nproc\n", + "gridpars['NPKS'] = minpeaks\n", + "gridpars['OMEGAFLOAT'] = omega_slop\n", + "gridpars['TOLSEQ'] = makemap_tol_seq\n", + "gridpars['SYMMETRY'] = symmetry\n", "\n", - "makemap_tol_seq = [0.02, 0.015, 0.01]\n", - "\n", - "gridpars = {\n", - " 'DSTOL' : 0.004,\n", - " 'OMEGAFLOAT' : omega_slop,\n", - " 'COSTOL' : np.cos(np.radians(90 - ds.ostep)),\n", - " 'NPKS' : int(minpeaks),\n", - " 'TOLSEQ' : makemap_tol_seq,\n", - " 'SYMMETRY' : symmetry,\n", - " 'RING1' : [1,0,],\n", - " 'RING2' : [0,],\n", - " 'NUL' : True,\n", - " 'FITPOS' : True,\n", - " 'tolangle' : 0.50,\n", - " 'toldist' : 100.,\n", - " 'NPROC' : nproc, # guess from cpu_count\n", - " 'NTHREAD' : 1 ,\n", - " }\n", - " \n", - "# grid to search\n", - "translations = [(t_x, t_y, t_z) \n", - " for t_x in range(-600, 601, 100)\n", - " for t_y in range(-600, 601, 100) \n", - " for t_z in range(-600, 601, 100) ]\n", - "# Cylinder: \n", - "# translations = [( x,y,z) for (x,y,z) in translations if (x*x+y*y)< 500*500 ]\n", - "#\n", + "translations = [(t_x, t_y, t_z) # grid to search\n", + " for t_x in range(-grid_xlim, grid_xlim+1, grid_step)\n", + " for t_y in range(-grid_ylim, grid_ylim+1, grid_step) \n", + " for t_z in range(-grid_zlim, grid_zlim+1, grid_step) ]\n", "\n", "import random\n", "random.seed(42) # reproducible\n", @@ -556,14 +599,22 @@ "source": [ "# run makemap against the selected grid peaks\n", "\n", - "symmetry = \"cubic\"\n", - "\n", "new_map_path = f'alltmp.map.new'\n", "new_grid_peaks_path = f'{sample}_{dataset}_3d_peaks_grid.flt.new'\n", "\n", "makemap_output = !makemap.py -p {oldparfile} -u {map_path} -U {new_map_path} -f {grid_peaks_path} -s {symmetry} -t {makemap_tol_seq[-1]} --omega_slop={omega_slop} --no_sort" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "6ace88c5-a7ae-4a90-94b1-1f27965fd1cb", + "metadata": {}, + "outputs": [], + "source": [ + "utils.plot_grain_histograms(new_grid_peaks_path, new_map_path, oldparfile, omega_slop, tol=makemap_tol_seq[-1])" + ] + }, { "cell_type": "code", "execution_count": null, @@ -621,19 +672,6 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "9c847bd2-62e5-442b-a580-1b585407cde8", - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# find the spike\n", - "absolute_minpks = 56" - ] - }, { "cell_type": "code", "execution_count": null, @@ -701,8 +739,6 @@ "source": [ "# run makemap again against all peaks\n", "\n", - "symmetry = \"cubic\"\n", - "\n", "new_filtered_map_path = f'{sample}_{dataset}_nice_grains.map.new'\n", "new_cf_3d_path = cf_3d_path + '.new'\n", "\n", @@ -796,6 +832,16 @@ "len(grains_final)" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "2c1cc664-b29d-4b8e-9159-1d31e31fcd47", + "metadata": {}, + "outputs": [], + "source": [ + "utils.plot_grain_histograms(new_cf_3d_path, new_filtered_map_path, oldparfile, omega_slop, tol=makemap_tol_seq[-1])" + ] + }, { "cell_type": "code", "execution_count": null, @@ -859,18 +905,6 @@ " os.remove(path)" ] }, - { - "cell_type": "code", - "execution_count": null, - "id": "22576f0f-539a-4169-8638-b5021bad6790", - "metadata": {}, - "outputs": [], - "source": [ - "# change to 0 to allow all cells to be run automatically\n", - "if 1:\n", - " raise ValueError(\"Hello!\")" - ] - }, { "cell_type": "code", "execution_count": null, @@ -878,26 +912,27 @@ "metadata": {}, "outputs": [], "source": [ - "# Now that we are happy with our indexing parameters, we can run the below cell to do this in bulk for many samples/datasets\n", + "# Now that we're happy with our indexing parameters, we can run the below cell to do this in bulk for many samples/datasets\n", "# by default this will do all samples in sample_list, all datasets with a prefix of dset_prefix\n", "# you can add samples and datasets to skip in skips_dict\n", "\n", + "# you can optionally skip samples\n", + "# skips_dict = {\n", + "# \"FeAu_0p5_tR\": [\"ff6\",]\n", + "# }\n", + "# otherwise by default skip nothing:\n", "skips_dict = {\n", - " \"FeAu_0p5_tR\": []\n", + " ds.sample: []\n", "}\n", "\n", - "# USER: Change this prefix to match the naming convention of your datasets\n", - "# e.g if your slices are formatted like [\"ff_z0\", \"ff_z1\", \"ff_z2\"] etc, then the prefix could be \"ff\" or \"ff_z\"\n", + "sample_list = [ds.sample, ]\n", "\n", - "dset_prefix = \"ff\"\n", + "samples_dict = utils.find_datasets_to_process(rawdata_path, skips_dict, dset_prefix, sample_list)\n", "\n", - "sample_list = [\"FeAu_0p5_tR\"]\n", - " \n", - "samples_dict = utils.find_datasets_to_process(ds.dataroot, skips_dict, dset_prefix, sample_list)\n", "print(samples_dict)\n", - "\n", - "# manual override example:\n", - "# samples_dict = {\"FeAu_0p5_tR\": [\"ff1\", \"ff2\"]}" + " \n", + "# manual override:\n", + "# samples_dict = {\"FeAu_0p5_tR_nscope\": [\"top_100um\", \"top_150um\"]}" ] }, { @@ -927,7 +962,8 @@ " if phase_str in hin.keys():\n", " print(f\"Already have grains for {dataset} in sample {sample}, skipping\")\n", " continue\n", - " \n", + " ds.parfile = parfile\n", + " ds.save()\n", " ds.phases = ds.get_phases_from_disk()\n", " ucell = ds.phases.unitcells[phase_str]\n", " \n", @@ -960,9 +996,7 @@ " grid_peaks_path = f'{sample}_{dataset}_3d_peaks_grid.flt'\n", " peaks_to_export.writefile(grid_peaks_path)\n", " \n", - " omegas_sorted = np.sort(ds.omega)[0]\n", - " omega_step = np.round(np.diff(omegas_sorted).mean(), 3)\n", - " omega_slop = omega_step/2\n", + " omega_slop = ds.ostep/2\n", " \n", " print('Launching grid index')\n", " grid_index_parallel(grid_peaks_path, oldparfile, tmp_output_path, gridpars, translations)\n", diff --git a/ImageD11/nbGui/TDXRD/2_merge_slices.ipynb b/ImageD11/nbGui/TDXRD/2_merge_slices.ipynb new file mode 100755 index 00000000..7aeb9e31 --- /dev/null +++ b/ImageD11/nbGui/TDXRD/2_merge_slices.ipynb @@ -0,0 +1,1160 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "d7a0cf0a", + "metadata": { + "papermill": { + "duration": 0.006454, + "end_time": "2025-02-17T13:42:50.829319", + "exception": false, + "start_time": "2025-02-17T13:42:50.822865", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "# Jupyter notebook based on ImageD11 to process scanning 3DXRD data\n", + "# Written by Haixing Fang, Jon Wright and James Ball\n", + "## Date: 21/02/2024" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee3ddc28", + "metadata": { + "papermill": { + "duration": 0.017851, + "end_time": "2025-02-17T13:42:50.853074", + "exception": false, + "start_time": "2025-02-17T13:42:50.835223", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f372b7a7", + "metadata": { + "papermill": { + "duration": 0.344849, + "end_time": "2025-02-17T13:42:51.201659", + "exception": false, + "start_time": "2025-02-17T13:42:50.856810", + "status": "completed" + }, + "tags": [ + "parameters" + ] + }, + "outputs": [], + "source": [ + "# this cell is tagged with 'parameters'\n", + "# to view the tag, select the cell, then find the settings gear icon (right or left sidebar) and look for Cell Tags\n", + "\n", + "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )\n", + "\n", + "dset_path = ''\n", + "\n", + "phase_str = 'Fe'\n", + "\n", + "z_translation_motor = \"samtz\"\n", + "\n", + "dset_prefix = \"ff\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d835bf9", + "metadata": { + "papermill": { + "duration": 1.245379, + "end_time": "2025-02-17T13:42:52.469521", + "exception": false, + "start_time": "2025-02-17T13:42:51.224142", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# import functions we need\n", + "\n", + "import os, glob, pprint\n", + "import numpy as np\n", + "import h5py\n", + "from tqdm.notebook import tqdm\n", + "\n", + "import matplotlib\n", + "%matplotlib widget\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# import utils\n", + "from ImageD11.nbGui import nb_utils as utils\n", + "\n", + "import ImageD11.grain\n", + "import ImageD11.indexing\n", + "import ImageD11.columnfile\n", + "from ImageD11.sinograms import properties, dataset\n", + "\n", + "from ImageD11.sym_u import find_uniq_u, getgroup, cubic\n", + "from xfab.symmetry import Umis, ROTATIONS\n", + "from scipy.spatial.transform import Rotation as R\n", + "import networkx as nx" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee0bca2c", + "metadata": { + "papermill": { + "duration": 0.029215, + "end_time": "2025-02-17T13:42:52.509173", + "exception": false, + "start_time": "2025-02-17T13:42:52.479958", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# desination of H5 files\n", + "# replace below with e.g.:\n", + "# dset_path = '/data/visitor/expt1234/20240101/PROCESSED_DATA/sample/dataset/sample_dataset.h5'\n", + "\n", + "# load the dataset from file\n", + "\n", + "ds = ImageD11.sinograms.dataset.load(dset_path)\n", + "\n", + "print(ds)\n", + "print(ds.shape)\n", + "\n", + "rawdata_path = ds.dataroot\n", + "processed_data_root_dir = ds.analysisroot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "613cc3a3", + "metadata": { + "papermill": { + "duration": 0.012703, + "end_time": "2025-02-17T13:42:52.527052", + "exception": false, + "start_time": "2025-02-17T13:42:52.514349", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "ds.phases = ds.get_phases_from_disk()\n", + "ds.phases.unitcells" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9169d34d", + "metadata": { + "papermill": { + "duration": 0.011312, + "end_time": "2025-02-17T13:42:52.541569", + "exception": false, + "start_time": "2025-02-17T13:42:52.530257", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# now let's select a phase to index from our parameters json\n", + "\n", + "ucell = ds.phases.unitcells[phase_str]\n", + "\n", + "print(ucell.lattice_parameters, ucell.spacegroup)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e3b5d68d", + "metadata": { + "papermill": { + "duration": 0.012904, + "end_time": "2025-02-17T13:42:52.558725", + "exception": false, + "start_time": "2025-02-17T13:42:52.545821", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# Now that we're happy with our indexing parameters, we can run the below cell to do this in bulk for many samples/datasets\n", + "# by default this will do all samples in sample_list, all datasets with a prefix of dset_prefix\n", + "# you can add samples and datasets to skip in skips_dict\n", + "\n", + "# you can optionally skip samples\n", + "# skips_dict = {\n", + "# \"FeAu_0p5_tR\": [\"ff6\",]\n", + "# }\n", + "# otherwise by default skip nothing:\n", + "skips_dict = {\n", + " ds.sample: []\n", + "}\n", + "\n", + "sample_list = [ds.sample, ]\n", + "\n", + "samples_dict = utils.find_datasets_to_process(rawdata_path, skips_dict, dset_prefix, sample_list)\n", + "\n", + "print(samples_dict)\n", + " \n", + "# manual override:\n", + "# samples_dict = {\"FeAu_0p5_tR_nscope\": [\"top_100um\", \"top_150um\"]}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87b45496", + "metadata": { + "papermill": { + "duration": 0.070269, + "end_time": "2025-02-17T13:42:52.632738", + "exception": false, + "start_time": "2025-02-17T13:42:52.562469", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# load all 3DXRD datasets for this sample\n", + "\n", + "from collections import OrderedDict\n", + "\n", + "# just take first sample for now\n", + "\n", + "sample = sample_list[0]\n", + "datasets = samples_dict[sample]\n", + "ds_dict = OrderedDict()\n", + "\n", + "# try to sort datasets alphabetically\n", + "\n", + "datasets_sorted = sorted(datasets)\n", + "\n", + "for dataset in datasets_sorted:\n", + " dset_path = os.path.join(processed_data_root_dir, sample, f\"{sample}_{dataset}\", f\"{sample}_{dataset}_dataset.h5\")\n", + " ds = ImageD11.sinograms.dataset.load(dset_path)\n", + " print(f\"I have a DataSet {ds.dset} in sample {ds.sample}\")\n", + " ds_dict[dataset] = ds" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4edac262", + "metadata": { + "papermill": { + "duration": 0.020151, + "end_time": "2025-02-17T13:42:52.658280", + "exception": false, + "start_time": "2025-02-17T13:42:52.638129", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# populate z translations\n", + "\n", + "for ds in ds_dict.values():\n", + " with h5py.File(ds.masterfile, 'r' ) as hin:\n", + " this_z_trans_value = hin[\"1.1/instrument/positioners\"][z_translation_motor][()]\n", + " ds.zpos = this_z_trans_value # this is in microns for samtz" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5b028319", + "metadata": { + "papermill": { + "duration": 0.614724, + "end_time": "2025-02-17T13:42:53.276467", + "exception": false, + "start_time": "2025-02-17T13:42:52.661743", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# load grains for each dataset and tie them to the dataset objects\n", + "for ds in ds_dict.values():\n", + " ds.grains = ds.get_grains_from_disk(phase_str)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "113c2fb3", + "metadata": { + "papermill": { + "duration": 0.013082, + "end_time": "2025-02-17T13:42:53.298262", + "exception": false, + "start_time": "2025-02-17T13:42:53.285180", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# get positions within the sample (set middle slice as zero position)\n", + "\n", + "middle_ds = list(ds_dict.values())[len(ds_dict.values())//2]\n", + "middle_pos = middle_ds.zpos\n", + "\n", + "for ds in ds_dict.values():\n", + " # adjust so that the first letterbox (lowest z so highest on the sample) has the highest value of zpos\n", + " ds.zpos_sample = middle_pos - ds.zpos\n", + " print(ds.zpos, ds.zpos_sample)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9b40b2c8", + "metadata": { + "papermill": { + "duration": 0.013815, + "end_time": "2025-02-17T13:42:53.315512", + "exception": false, + "start_time": "2025-02-17T13:42:53.301697", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "for inc, ds in enumerate(ds_dict.values()):\n", + " for gid, grain in enumerate(ds.grains):\n", + " grain.pos_sample = grain.translation + np.array([0., 0., ds.zpos_sample * 1000])\n", + " grain.dataset = ds.dsname\n", + " grain.z_slice = inc\n", + " grain.gid = gid\n", + " grain.ref_unitcell = ucell\n", + " grain.mean_int = float(grain.intensity_info.split('mean = ')[1].split(' ,')[0])\n", + " \n", + " utils.get_rgbs_for_grains(ds.grains)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9186c7c9", + "metadata": { + "papermill": { + "duration": 0.010577, + "end_time": "2025-02-17T13:42:53.330899", + "exception": false, + "start_time": "2025-02-17T13:42:53.320322", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "all_grains = []\n", + "for ds in ds_dict.values():\n", + " all_grains.extend(ds.grains)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db6232c1", + "metadata": { + "papermill": { + "duration": 0.011207, + "end_time": "2025-02-17T13:42:53.345624", + "exception": false, + "start_time": "2025-02-17T13:42:53.334417", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "print(all_grains[0].pos_sample, all_grains[0].translation)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b26bb116", + "metadata": { + "papermill": { + "duration": 0.231902, + "end_time": "2025-02-17T13:42:53.581600", + "exception": false, + "start_time": "2025-02-17T13:42:53.349698", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "centre_plot = False\n", + "\n", + "fig = plt.figure(figsize=(12, 12))\n", + "ax = fig.add_subplot(projection='3d')\n", + "\n", + "import matplotlib.cm as cm\n", + "\n", + "colors = cm.rainbow(np.linspace(0, 1, len(list(ds_dict.values()))))\n", + "\n", + "for ds in ds_dict.values():\n", + " xx = [grain.pos_sample[0] for grain in ds.grains]\n", + " yy = [grain.pos_sample[1] for grain in ds.grains]\n", + " zz = [grain.pos_sample[2] for grain in ds.grains]\n", + " scatterplot = ax.scatter(xx, yy, zz, c=[grain.rgb_z for grain in ds.grains], s=[0.1*np.power(g.mean_int, 2/3) for g in ds.grains], label=ds.grains[0].z_slice)\n", + "\n", + "ax.set_aspect('equal')\n", + "ax.set_title(\"Grains coloured by ipf-z\")\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "ax.set_zlabel(\"z\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c36a4bc-2442-4416-a749-db4503f89161", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "centre_plot = False\n", + "\n", + "fig = plt.figure(figsize=(12, 12))\n", + "ax = fig.add_subplot(projection='3d')\n", + "\n", + "import matplotlib.cm as cm\n", + "\n", + "colors = cm.rainbow(np.linspace(0, 1, len(list(ds_dict.values()))))\n", + "\n", + "for ds in ds_dict.values():\n", + " xx = [grain.pos_sample[0] for grain in ds.grains]\n", + " yy = [grain.pos_sample[1] for grain in ds.grains]\n", + " zz = [grain.pos_sample[2] for grain in ds.grains]\n", + " # col = [len(grain.peaks_3d) for grain in ds.grains]\n", + " # col = [grain.z_slice for grain in ds.grains]\n", + " scatterplot = ax.scatter(xx, yy, zz, c=colors[ds.grains[0].z_slice], label=ds.grains[0].z_slice)\n", + "ax.set_aspect('equal')\n", + "# plt.colorbar(scatterplot)\n", + "ax.set_title(\"Grains coloured by z slice\")\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "ax.set_zlabel(\"z\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a5c12d1-7838-4973-91a4-37df07ba877f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# grain deduplication philosophy\n", + "# create a Graph with networkx - each grain is a node on the graph\n", + "# build an adjacency matrix - every grain vs every other grain\n", + "# vectors on the graph are drawn based on whether two grains are considered to match\n", + "# then extract the connected components of the graph" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ee69756c-06f1-4e76-b843-520d80b96256", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "len(all_grains)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bdc2814a-0459-4868-bd45-6f0309a8e6e0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "crystal_system_number = 7 # cubic\n", + "\n", + "def misorien_deg(U1, U2, crystal_system_number=7):\n", + " return Umis(U1, U2, crystal_system_number)[:, 1].min() # 7 == cubic\n", + "\n", + "# euclidean distance function\n", + "def eudis(v1, v2):\n", + " return np.linalg.norm(v1-v2)\n", + "\n", + "def are_grains_duplicate(grain_a, grain_b, distance_tolerance=25, angle_tolerance=2):\n", + " # are they the same grain?\n", + " if grain_a is grain_b:\n", + " return False\n", + " # # are they from the same slice?\n", + " # if grain_a.z_slice == grain_b.z_slice:\n", + " # return False\n", + " # now check their euclidean distance\n", + " translation = eudis(grain_a.pos_sample, grain_b.pos_sample)\n", + " if translation > distance_tolerance:\n", + " return False\n", + " misorien = misorien_deg(grain_a.U, grain_b.U)\n", + " if misorien > angle_tolerance:\n", + " return False\n", + " # if we got here, we have a misorientation match\n", + " return True" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "192d9d3d-d40a-46f1-b290-eac40af208ef", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "adjacency_matrix = np.zeros((len(all_grains), len(all_grains))).astype(bool)\n", + "inds = np.array(np.triu_indices(adjacency_matrix.shape[0])).T # upper triangular indices to the adjacency matrix\n", + "\n", + "distance_tolerance_for_merging_grains = 150\n", + "angular_tolerance_for_merging_grains = 0.5\n", + "\n", + "for ind in tqdm(inds):\n", + " i_a, i_b = ind\n", + " grain_a = all_grains[i_a]\n", + " grain_b = all_grains[i_b]\n", + " if are_grains_duplicate(grain_a, grain_b, distance_tolerance_for_merging_grains, angular_tolerance_for_merging_grains):\n", + " adjacency_matrix[*ind] = 1\n", + "\n", + "print(np.sum(adjacency_matrix))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b51f4bf-a6db-46c8-b358-ffa3185ee051", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# build networkx graph\n", + "\n", + "G = nx.from_numpy_array(adjacency_matrix)\n", + "components = list(nx.connected_components(G))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c21b848-f4c0-419b-9969-084f026a6e92", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "def merge_grains(grains_to_merge):\n", + " grain_positions = np.array([g.pos_sample for g in grains_to_merge])\n", + " \n", + " # take first grain in grains_to_merge\n", + " # take the fundamental zone of that grain\n", + " # move all other grains into the same fundamental zone\n", + " first_grain = grains_to_merge[0]\n", + " umats_fz = []\n", + " umats_fz.append(first_grain.U)\n", + " for g in grains_to_merge[1:]:\n", + " umis_out = Umis(g.U, first_grain.U, 7)\n", + " rot_operator_idx = np.argmin(umis_out[:, 1])\n", + " rot_operator = ROTATIONS[7][rot_operator_idx]\n", + " second_grain_in_fz = g.U @ rot_operator.T\n", + " umats_fz.append(second_grain_in_fz)\n", + " \n", + " grain_umats = np.array(umats_fz)\n", + " # find_uniq_u has corner cases!\n", + " # grain_umats = np.array([find_uniq_u(g.U, getgroup( 'cubic' )()) for g in grains_to_merge])\n", + " grain_as = np.array([np.linalg.inv(g.B) for g in grains_to_merge])\n", + " grain_volumes = np.array([g.mean_int for g in grains_to_merge])\n", + " vol_weighted_umat = R.from_matrix(grain_umats).mean(weights=grain_volumes).as_matrix()\n", + " vol_weighted_position = np.average(grain_positions, weights=grain_volumes, axis=0)\n", + " vol_weighted_amat = np.average(grain_as, weights=grain_volumes, axis=0)\n", + " vol_weighted_bmat = np.linalg.inv(vol_weighted_amat)\n", + " vol_weighted_ubi = np.linalg.inv(vol_weighted_umat.dot(vol_weighted_bmat))\n", + " new_grain = ImageD11.grain.grain(vol_weighted_ubi)\n", + " new_grain.pos_sample = vol_weighted_position\n", + " new_grain.names = [g.name for g in grains_to_merge]\n", + " new_grain.mean_int = np.sum(grain_volumes)\n", + " \n", + " # new grain should be close to first grain\n", + " assert eudis(new_grain.pos_sample, grains_to_merge[0].pos_sample) < 200, eudis(new_grain.pos_sample, grains_to_merge[0].pos_sample)\n", + " # print(misorien_deg(new_grain.U, grains_to_merge[0].U))\n", + " assert misorien_deg(new_grain.U, grains_to_merge[0].U) < 1, misorien_deg(new_grain.U, grains_to_merge[0].U)\n", + " \n", + " return new_grain" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e5a0dc60-ea9c-4f92-b43d-e4231512cfff", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# build list of merged grains\n", + "merged_grains = []\n", + "# comp is a list of dictionaries\n", + "for comp in tqdm(list(nx.connected_components(G))):\n", + " # list of grain IDs\n", + " cl = list(comp)\n", + " # list of grains\n", + " grains_here = [all_grains[inc] for inc in cl]\n", + " if len(grains_here) == 1:\n", + " merged_grains.append(grains_here[0])\n", + " else:\n", + " gnew = merge_grains(grains_here)\n", + " merged_grains.append(gnew)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d2952c83-dac9-4dd9-ae25-8e05e533cea8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "for g in merged_grains:\n", + " g.ref_unitcell = ucell\n", + "\n", + "utils.get_rgbs_for_grains(merged_grains)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a6da4af2-ba72-413a-af8e-a8c3ebfcffbc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "centre_plot = False\n", + "\n", + "fig = plt.figure(figsize=(12, 12))\n", + "ax = fig.add_subplot(projection='3d')\n", + "\n", + "xx = [grain.pos_sample[0] for grain in merged_grains]\n", + "yy = [grain.pos_sample[1] for grain in merged_grains]\n", + "zz = [grain.pos_sample[2] for grain in merged_grains]\n", + "# colour by if we have a merge or not\n", + "# c = [colors[adjacency_matrix[:, inc].sum()*5] for inc, grain in enumerate(all_grains)]\n", + "c = [grain.rgb_z for grain in merged_grains]\n", + "scatterplot = ax.scatter(xx, yy, zz, c=c, s=[0.1*np.power(g.mean_int, 2/3) for g in merged_grains])\n", + "# ax.set_xlim(-200,200)\n", + "# ax.set_ylim(-200,200)\n", + "# ax.set_zlim(-100,100)\n", + "ax.set_aspect('equal')\n", + "# plt.colorbar(scatterplot)\n", + "ax.set_title(\"Merged Grains\")\n", + "ax.set_xlabel(\"x\")\n", + "ax.set_ylabel(\"y\")\n", + "ax.set_zlabel(\"z\")\n", + "plt.show()" + ] + } + ], + "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" + }, + "papermill": { + "default_parameters": {}, + "duration": 23.994739, + "end_time": "2025-02-17T13:43:13.919619", + "environment_variables": {}, + "exception": null, + "input_path": "../ImageD11/nbGui/TDXRD/2_merge_slices.ipynb", + "output_path": "/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/PROCESSED_DATA/20250127_JADB/friedel/nb_out/2_merge_slices_out.ipynb", + "parameters": { + "PYTHONPATH": "../", + "dset_path": "/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/PROCESSED_DATA/20250127_JADB/friedel/FeAu_0p5_tR/FeAu_0p5_tR_ff1/FeAu_0p5_tR_ff1_dataset.h5", + "dset_prefix": "ff", + "phase_str": "Fe", + "z_translation_motor": "samtz" + }, + "start_time": "2025-02-17T13:42:49.924880", + "version": "2.6.0" + }, + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "state": { + "082633e67fad4a8a88d2039503e3df62": { + "model_module": "jupyter-matplotlib", + "model_module_version": "^0.11", + "model_name": "ToolbarModel", + "state": { + "_current_action": "", + "_dom_classes": [], + "_model_module": "jupyter-matplotlib", + "_model_module_version": "^0.11", + "_model_name": "ToolbarModel", + "_view_count": null, + "_view_module": "jupyter-matplotlib", + "_view_module_version": "^0.11", + "_view_name": "ToolbarView", + "button_style": "", + "collapsed": true, + "layout": "IPY_MODEL_cba0b97ca2f74cf6857263ca8fd166c3", + "orientation": "vertical", + "tabbable": null, + "toolitems": [ + [ + "Home", + "Reset original view", + "home", + "home" + ], + [ + "Back", + "Back to previous view", + "arrow-left", + "back" + ], + [ + "Forward", + "Forward to next view", + "arrow-right", + "forward" + ], + [ + "Pan", + "Left button pans, Right button zooms\nx/y fixes axis, CTRL fixes aspect", + "arrows", + "pan" + ], + [ + "Zoom", + "Zoom to rectangle\nx/y fixes axis", + "square-o", + "zoom" + ], + [ + "Download", + "Download plot", + "floppy-o", + "save_figure" + ] + ], + "tooltip": null + } + }, + "219b70b5dd864ed5873e6670dc71ba36": { + "model_module": "jupyter-matplotlib", + "model_module_version": "^0.11", + "model_name": "MPLCanvasModel", + "state": { + "_cursor": "pointer", + "_data_url": "data:image/png;base64,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", + "_dom_classes": [], + "_figure_label": "Figure", + "_image_mode": "full", + "_message": "", + "_model_module": "jupyter-matplotlib", + "_model_module_version": "^0.11", + "_model_name": "MPLCanvasModel", + "_rubberband_height": 0, + "_rubberband_width": 0, + "_rubberband_x": 0, + "_rubberband_y": 0, + "_size": [ + 640, + 480 + ], + "_view_count": null, + "_view_module": "jupyter-matplotlib", + "_view_module_version": "^0.11", + "_view_name": "MPLCanvasView", + "capture_scroll": false, + "footer_visible": true, + "header_visible": true, + "layout": "IPY_MODEL_c882b1d970284356908b0eb39c0bac07", + "pan_zoom_throttle": 33, + "resizable": true, + "tabbable": null, + "toolbar": "IPY_MODEL_2c1f101964a34f55b9b2a65536320b35", + "toolbar_position": "left", + "toolbar_visible": "fade-in-fade-out", + "tooltip": null + } + }, + "2c1f101964a34f55b9b2a65536320b35": { + "model_module": "jupyter-matplotlib", + "model_module_version": "^0.11", + "model_name": "ToolbarModel", + "state": { + "_current_action": "", + "_dom_classes": [], + "_model_module": "jupyter-matplotlib", + "_model_module_version": "^0.11", + "_model_name": "ToolbarModel", + "_view_count": null, + "_view_module": "jupyter-matplotlib", + "_view_module_version": "^0.11", + "_view_name": "ToolbarView", + "button_style": "", + "collapsed": true, + "layout": "IPY_MODEL_7b30e545607f482480b5830bf9fd9e97", + "orientation": "vertical", + "tabbable": null, + "toolitems": [ + [ + "Home", + "Reset original view", + "home", + "home" + ], + [ + "Back", + "Back to previous view", + "arrow-left", + "back" + ], + [ + "Forward", + "Forward to next view", + "arrow-right", + "forward" + ], + [ + "Pan", + "Left button pans, Right button zooms\nx/y fixes axis, CTRL fixes aspect", + "arrows", + "pan" + ], + [ + "Zoom", + "Zoom to rectangle\nx/y fixes axis", + "square-o", + "zoom" + ], + [ + "Download", + "Download plot", + "floppy-o", + "save_figure" + ] + ], + "tooltip": null + } + }, + "3a2b7132a3b44bee8fb193824190dd45": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6f13e616b3e54aa3bcf6c2ac3d321e9b": { + "model_module": "jupyter-matplotlib", + "model_module_version": "^0.11", + "model_name": "MPLCanvasModel", + "state": { + "_cursor": "pointer", + "_data_url": "data:image/png;base64,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", + "_dom_classes": [], + "_figure_label": "Figure", + "_image_mode": "full", + "_message": "", + "_model_module": "jupyter-matplotlib", + "_model_module_version": "^0.11", + "_model_name": "MPLCanvasModel", + "_rubberband_height": 0, + "_rubberband_width": 0, + "_rubberband_x": 0, + "_rubberband_y": 0, + "_size": [ + 1200, + 1200 + ], + "_view_count": null, + "_view_module": "jupyter-matplotlib", + "_view_module_version": "^0.11", + "_view_name": "MPLCanvasView", + "capture_scroll": false, + "footer_visible": true, + "header_visible": true, + "layout": "IPY_MODEL_3a2b7132a3b44bee8fb193824190dd45", + "pan_zoom_throttle": 33, + "resizable": true, + "tabbable": null, + "toolbar": "IPY_MODEL_082633e67fad4a8a88d2039503e3df62", + "toolbar_position": "left", + "toolbar_visible": "fade-in-fade-out", + "tooltip": null + } + }, + "7b30e545607f482480b5830bf9fd9e97": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c882b1d970284356908b0eb39c0bac07": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cba0b97ca2f74cf6857263ca8fd166c3": { + "model_module": "@jupyter-widgets/base", + "model_module_version": "2.0.0", + "model_name": "LayoutModel", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "2.0.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "2.0.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border_bottom": null, + "border_left": null, + "border_right": null, + "border_top": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + } + }, + "version_major": 2, + "version_minor": 0 + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/ImageD11/nbGui/TDXRD/4_3DXRD_merge_slices.ipynb b/ImageD11/nbGui/TDXRD/4_3DXRD_merge_slices.ipynb deleted file mode 100755 index cb540a34..00000000 --- a/ImageD11/nbGui/TDXRD/4_3DXRD_merge_slices.ipynb +++ /dev/null @@ -1,449 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Jupyter notebook based on ImageD11 to process scanning 3DXRD data\n", - "# Written by Haixing Fang, Jon Wright and James Ball\n", - "## Date: 21/02/2024" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "exec(open('/data/id11/nanoscope/install_ImageD11_from_git.py').read())\n", - "PYTHONPATH = setup_ImageD11_from_git( ) # ( os.path.join( os.environ['HOME'],'Code'), 'ImageD11_git' )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# import functions we need\n", - "\n", - "import os, glob, pprint\n", - "import numpy as np\n", - "import h5py\n", - "from tqdm.notebook import tqdm\n", - "\n", - "import matplotlib\n", - "%matplotlib widget\n", - "from matplotlib import pyplot as plt\n", - "\n", - "# import utils\n", - "from ImageD11.nbGui import nb_utils as utils\n", - "\n", - "import ImageD11.grain\n", - "import ImageD11.indexing\n", - "import ImageD11.columnfile\n", - "from ImageD11.sinograms import properties, dataset\n", - "\n", - "from ImageD11.blobcorrector import eiger_spatial" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# desination of H5 files\n", - "# replace below with e.g.:\n", - "# dset_path = '/data/visitor/expt1234/20240101/PROCESSED_DATA/sample/dataset/sample_dataset.h5'\n", - "\n", - "dset_path = ''\n", - "\n", - "# load the dataset from file\n", - "\n", - "ds = ImageD11.sinograms.dataset.load(dset_path)\n", - "\n", - "print(ds)\n", - "print(ds.shape)\n", - "\n", - "rawdata_path = ds.dataroot\n", - "processed_data_root_dir = ds.analysisroot" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "ds.phases = ds.get_phases_from_disk()\n", - "ds.phases.unitcells" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# now let's select a phase to index from our parameters json\n", - "phase_str = 'Fe'\n", - "\n", - "ucell = ds.phases.unitcells[phase_str]\n", - "\n", - "print(ucell.lattice_parameters, ucell.spacegroup)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# USER: pick a sample you want to import\n", - "\n", - "skips_dict = {\n", - " ds.sample: []\n", - "}\n", - "\n", - "# USER: Change this prefix to match the naming convention of your datasets\n", - "# e.g if your slices are formatted like [\"ff_z0\", \"ff_z1\", \"ff_z2\"] etc, then the prefix could be \"ff\" or \"ff_z\"\n", - "\n", - "dset_prefix = \"ff\"\n", - "\n", - "sample_list = [ds.sample]\n", - "\n", - "samples_dict = utils.find_datasets_to_process(rawdata_path, skips_dict, dset_prefix, sample_list)\n", - "\n", - "print(samples_dict)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# load all 3DXRD datasets for this sample\n", - "\n", - "from collections import OrderedDict\n", - "\n", - "# just take first sample for now\n", - "\n", - "sample = sample_list[0]\n", - "datasets = samples_dict[sample]\n", - "ds_dict = OrderedDict()\n", - "\n", - "# try to sort datasets alphabetically\n", - "\n", - "datasets_sorted = sorted(datasets)\n", - "\n", - "for dataset in datasets_sorted:\n", - " dset_path = os.path.join(processed_data_root_dir, sample, f\"{sample}_{dataset}\", f\"{sample}_{dataset}_dataset.h5\")\n", - " ds = ImageD11.sinograms.dataset.load(dset_path)\n", - " print(f\"I have a DataSet {ds.dset} in sample {ds.sample}\")\n", - " ds_dict[dataset] = ds" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# populate z translations\n", - "\n", - "z_translation_motor = \"samtz\"\n", - "\n", - "for ds in ds_dict.values():\n", - " with h5py.File(ds.masterfile, 'r' ) as hin:\n", - " this_z_trans_value = hin[\"1.1/instrument/positioners\"][z_translation_motor][()]\n", - " ds.zpos = this_z_trans_value # this is in microns for samtz" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# load grains for each dataset and tie them to the dataset objects\n", - "for ds in ds_dict.values():\n", - " ds.grains = ds.get_grains_from_disk(phase_str)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# get positions within the sample (set middle slice as zero position)\n", - "\n", - "middle_ds = list(ds_dict.values())[len(ds_dict.values())//2]\n", - "middle_pos = middle_ds.zpos\n", - "\n", - "for ds in ds_dict.values():\n", - " # adjust so that the first letterbox (lowest z so highest on the sample) has the highest value of zpos\n", - " ds.zpos_sample = middle_pos - ds.zpos\n", - " print(ds.zpos, ds.zpos_sample)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "for inc, ds in enumerate(ds_dict.values()):\n", - " for gid, grain in enumerate(ds.grains):\n", - " grain.pos_sample = grain.translation + np.array([0., 0., ds.zpos_sample * 1000])\n", - " grain.dataset = ds.dsname\n", - " grain.z_slice = inc\n", - " grain.gid = gid" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "all_grains = []\n", - "for ds in ds_dict.values():\n", - " all_grains.extend(ds.grains)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "print(all_grains[0].pos_sample, all_grains[0].translation)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "centre_plot = False\n", - "\n", - "fig = plt.figure(figsize=(12, 12))\n", - "ax = fig.add_subplot(projection='3d')\n", - "\n", - "import matplotlib.cm as cm\n", - "\n", - "colors = cm.rainbow(np.linspace(0, 1, len(list(ds_dict.values()))))\n", - "\n", - "for ds in ds_dict.values():\n", - " xx = [grain.pos_sample[0] for grain in ds.grains]\n", - " yy = [grain.pos_sample[1] for grain in ds.grains]\n", - " zz = [grain.pos_sample[2] for grain in ds.grains]\n", - " # col = [len(grain.peaks_3d) for grain in ds.grains]\n", - " # col = [grain.z_slice for grain in ds.grains]\n", - " scatterplot = ax.scatter(xx, yy, zz, c=colors[ds.grains[0].z_slice], label=ds.grains[0].z_slice)\n", - "ax.set_xlim(-200,200)\n", - "ax.set_ylim(-200,200)\n", - "ax.set_zlim(-100,100)\n", - "# plt.colorbar(scatterplot)\n", - "ax.set_title(\"Grains coloured by z slice\")\n", - "ax.set_xlabel(\"x\")\n", - "ax.set_ylabel(\"y\")\n", - "ax.set_zlabel(\"z\")\n", - "ax.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# now we can look for duplicate grains\n", - "# this is a very simple duplicate grain detector\n", - "\n", - "distance_tolerance = 25/2 # microns\n", - "angle_tolerance = 2 # degrees\n", - "\n", - "def eudis(v1, v2):\n", - " return np.linalg.norm(v1-v2)\n", - "\n", - "from xfab.symmetry import Umis\n", - "\n", - "# USER: Check the symmetry here\n", - "# crystal_system number must be one of 1: Triclinic, 2: Monoclinic, 3: Orthorhombic, 4: Tetragonal, 5: Trigonal, 6: Hexagonal, 7: Cubic\n", - "\n", - "crystal_system_number = 7 # cubic\n", - "\n", - "def misorien_deg(U1, U2):\n", - " return np.min(Umis(U1, U2, crystal_system_number), axis=0)[1] # 7 == cubic\n", - "\n", - "matches = []\n", - "\n", - "for grain_a in all_grains:\n", - " for grain_b in all_grains:\n", - " if grain_a.z_slice == grain_b.z_slice:\n", - " # grains are in the same slice, skip\n", - " continue\n", - " translation = eudis(grain_a.pos_sample, grain_b.pos_sample)\n", - " if translation < distance_tolerance:\n", - " # might have a match in translation, now check misorientation\n", - " misorien = misorien_deg(grain_a.U, grain_b.U)\n", - " if misorien < angle_tolerance:\n", - " print(f\"Found match! Grain A: {grain_a.z_slice}:{grain_a.gid} | Grain B: {grain_b.z_slice}:{grain_b.gid} | Distance: {translation:.0f} um | Angle: {misorien:.3f} deg\")\n", - " matches.append((grain_a, grain_b))" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "# how do we determine good choices of parameters?\n", - "# one way is to follow Louca and try a range of parameters and plot the results" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "def get_n_matches(dist_tol, ang_tol):\n", - " n_matches = 0\n", - " for grain_a in all_grains:\n", - " for grain_b in all_grains:\n", - " if grain_a.z_slice == grain_b.z_slice:\n", - " # grains are in the same slice, skip\n", - " continue\n", - " translation = eudis(grain_a.pos_sample, grain_b.pos_sample)\n", - " if translation < dist_tol:\n", - " # might have a match in translation, now check misorientation\n", - " misorien = misorien_deg(grain_a.U, grain_b.U)\n", - " if misorien < ang_tol:\n", - " n_matches += 1\n", - " return n_matches" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "dist_tols = [1, 2, 5, 10, 15, 20, 25]\n", - "ang_tols = [1, 2, 3, 4, 5]\n", - "\n", - "tol_check_results = {}\n", - "\n", - "print(\"dist_tol | ang_tol | n_matches\")\n", - "\n", - "for dist_tol in dist_tols:\n", - " for ang_tol in ang_tols:\n", - "\n", - " n_matches = get_n_matches(dist_tol, ang_tol)\n", - " tol_check_results[dist_tol, ang_tol] = n_matches\n", - " print(f\"{dist_tol} | {ang_tol} | {n_matches}\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "fig, ax = plt.subplots()\n", - "\n", - "for ang_tol in ang_tols:\n", - " n_matches_at_this_angle = []\n", - " for dist_tol in dist_tols:\n", - " n_matches_at_this_distance = tol_check_results[dist_tol, ang_tol]\n", - " n_matches_at_this_angle.append(n_matches_at_this_distance)\n", - " \n", - " ax.plot(dist_tols, n_matches_at_this_angle, label=ang_tol)\n", - " \n", - "ax.legend()\n", - "\n", - "ax.set_xlabel(\"Distance tolerance (um)\")\n", - "ax.set_ylabel(\"Number of merges\")\n", - "ax.set_title(\"Legend is angle tolerance (deg)\")\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "tags": [] - }, - "outputs": [], - "source": [ - "# please note that this is a very simple duplicate grain detector\n", - "# it doesn't consider things like whether grains can match to multiple other grains\n", - "# or whether there could be duplicate grains within a single slice\n", - "# we're also not currently considering how to merge grains together\n", - "# this involves averaging the positions (easy) and the UBIs (not so easy)\n", - "# hopefully this notebook gives you a starting point though!" - ] - } - ], - "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": 4 -} diff --git a/ImageD11/nbGui/TDXRD/1_3DXRD_refine_parameters.ipynb b/ImageD11/nbGui/TDXRD/use_only_if_needed/1_3DXRD_refine_parameters.ipynb similarity index 100% rename from ImageD11/nbGui/TDXRD/1_3DXRD_refine_parameters.ipynb rename to ImageD11/nbGui/TDXRD/use_only_if_needed/1_3DXRD_refine_parameters.ipynb diff --git a/ImageD11/nbGui/TDXRD/3_3DXRD_look_at_peaks.ipynb b/ImageD11/nbGui/TDXRD/use_only_if_needed/3_look_at_peaks.ipynb similarity index 100% rename from ImageD11/nbGui/TDXRD/3_3DXRD_look_at_peaks.ipynb rename to ImageD11/nbGui/TDXRD/use_only_if_needed/3_look_at_peaks.ipynb diff --git a/ImageD11/parameters.py b/ImageD11/parameters.py index 140bc84f..19a2781c 100644 --- a/ImageD11/parameters.py +++ b/ImageD11/parameters.py @@ -112,6 +112,8 @@ def get_xfab_pars_dict(self, phase_name=None): pars_dict = geometry_pars_dict.copy() # add in the phase pars pars_dict.update(phase_pars_dict) + # re-add the geometry dict to override things like filename if present + pars_dict.update(geometry_pars_dict) else: # just copy the geometry dict pars_dict = geometry_pars_dict.copy() diff --git a/test/papermill_test_notebooks.py b/test/papermill_test_notebooks.py index abe02bfd..a95ef370 100644 --- a/test/papermill_test_notebooks.py +++ b/test/papermill_test_notebooks.py @@ -25,6 +25,8 @@ nb_base_prefix = os.path.join('..', 'ImageD11', 'nbGui') scan_nb_prefix = os.path.join(nb_base_prefix, 'S3DXRD') +bb_nb_prefix = os.path.join(nb_base_prefix, 'TDXRD') + # there are two levels of testing # does the notebook work without errors? @@ -49,6 +51,8 @@ def notebook_route(base_dir, notebook_paths, notebook_param_dicts, notebook_out_ notebook_paths: Ordered list of paths to the notebooks, to be deployed one after the other notebook_param_dicts: Ordered list of dictionaries of parameters, one dict per notebook to be executed """ + if len(notebook_paths) != len(notebook_param_dicts): + raise ValueError('Mismatch between number of notebooks and param dicts!') if os.path.exists(base_dir): raise ValueError('output test directory already exists:', base_dir) os.mkdir(base_dir) @@ -491,13 +495,234 @@ def test_FeAu_JADB_pbp(): 'dset_prefix': "top_", }, ] - if len(scan_nb_names) != len(scan_nb_params): - raise ValueError('Mismatch between number of notebooks and param dicts!') scan_nb_paths = [os.path.join(scan_nb_prefix, name) for name in scan_nb_names] notebook_route(tomo_dir, scan_nb_paths, scan_nb_params) + +def test_FeAu_JADB_bb(): + proc_dir = '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/PROCESSED_DATA/20250127_JADB/default' + nb_names = [ + '0_segment_frelon.ipynb', + '1_index_default.ipynb', + '2_merge_slices.ipynb' + ] + sample = 'FeAu_0p5_tR' + dataset = 'ff1' # first of two layers + dset_file = os.path.join(proc_dir, sample, f'{sample}_{dataset}', f'{sample}_{dataset}_dataset.h5') + bgfile = None + maskfile = '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/mask.edf' + nb_params = [ + {'PYTHONPATH': sys.path[0], # 0_segment_frelon.ipynb + 'splinefile': ['/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/frelon36_spline_20240604_dx.edf','/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/frelon36_spline_20240604_dy.edf'], + 'bgfile': bgfile, + 'maskfile': maskfile, + 'detector': 'frelon3', + 'omegamotor': 'diffrz', + 'dtymotor': 'diffty', + 'options': { + "bgfile":bgfile, + "maskfile":maskfile, + "threshold":70, + "smoothsigma":1.0, + "bgc":0.9, + "minpx":3, + "m_offset_thresh":100, + "m_ratio_thresh":150, + }, + 'dataroot': '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/RAW_DATA/', + 'analysisroot': proc_dir, + 'sample': sample, + 'dataset': dataset, + 'dset_prefix': "ff" + }, + {'PYTHONPATH': sys.path[0], # 1_index_default.ipynb + 'dset_path': dset_file, + 'phase_str': 'Fe', + 'parfile': '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/pars_tdxrd.json', + 'cf_strong_frac': 0.9837, + 'cf_strong_dsmax': 1.01, + 'cf_strong_dstol': 0.01, + 'indexer_ds_tol': 0.01, + 'rings_for_gen': [0, 1], + 'rings_for_scoring': [0, 1, 2, 3], + 'hkl_tols_seq': [0.01, 0.02, 0.03, 0.04], + 'fracs': [0.9, 9.75], + 'max_grains': 1000, + 'makemap_hkl_tol_seq': [0.05, 0.025, 0.01], + 'symmetry': 'cubic', + 'absolute_minpks': 120, + 'dset_prefix': "ff" + }, + {'PYTHONPATH': sys.path[0], # 2_merge_slices.ipynb + 'dset_path': dset_file, + 'phase_str': 'Fe', + 'z_translation_motor': 'samtz', + 'dset_prefix': "ff" + }, + ] + nb_paths = [os.path.join(bb_nb_prefix, name) for name in nb_names] + notebook_route(proc_dir, nb_paths, nb_params) + + + +def test_FeAu_JADB_bb_grid(): + proc_dir = '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/PROCESSED_DATA/20250127_JADB/grid' + nb_names = [ + '0_segment_frelon.ipynb', + '1_index_grid.ipynb', + '2_merge_slices.ipynb' + ] + sample = 'FeAu_0p5_tR' + dataset = 'ff1' # first of two layers + dset_file = os.path.join(proc_dir, sample, f'{sample}_{dataset}', f'{sample}_{dataset}_dataset.h5') + bgfile = None + maskfile = '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/mask.edf' + nb_params = [ + {'PYTHONPATH': sys.path[0], # 0_segment_frelon.ipynb + 'splinefile': ['/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/frelon36_spline_20240604_dx.edf','/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/frelon36_spline_20240604_dy.edf'], + 'bgfile': bgfile, + 'maskfile': maskfile, + 'detector': 'frelon3', + 'omegamotor': 'diffrz', + 'dtymotor': 'diffty', + 'options': { + "bgfile":bgfile, + "maskfile":maskfile, + "threshold":70, + "smoothsigma":1.0, + "bgc":0.9, + "minpx":3, + "m_offset_thresh":100, + "m_ratio_thresh":150, + }, + 'dataroot': '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/RAW_DATA/', + 'analysisroot': proc_dir, + 'sample': sample, + 'dataset': dataset, + 'dset_prefix': "ff" + }, + {'PYTHONPATH': sys.path[0], # 1_index_grid.ipynb + 'dset_path': dset_file, + 'phase_str': 'Fe', + 'parfile': '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/pars_tdxrd.json', + 'cf_strong_frac': 0.9837, + 'cf_strong_dsmax': 1.01, + 'cf_strong_dstol': 0.01, + 'indexer_ds_tol': 0.01, + 'rings_to_use': [0, 1, 3], + 'symmetry': 'cubic', + 'makemap_tol_seq': [0.02, 0.015, 0.01], + 'gridpars': { + 'DSTOL' : 0.004, + 'RING1' : [1,0,], + 'RING2' : [0,], + 'NUL' : True, + 'FITPOS' : True, + 'tolangle' : 0.50, + 'toldist' : 100., + 'NTHREAD' : 1 , + }, + 'grid_xlim': 600, + 'grid_ylim': 600, + 'grid_zlim': 200, + 'grid_step': 100, + 'frac': 0.85, + 'absolute_minpks': 56, + 'dset_prefix': "ff" + }, + {'PYTHONPATH': sys.path[0], # 2_merge_slices.ipynb + 'dset_path': dset_file, + 'phase_str': 'Fe', + 'z_translation_motor': 'samtz', + 'dset_prefix': "ff" + }, + ] + nb_paths = [os.path.join(bb_nb_prefix, name) for name in nb_names] + notebook_route(proc_dir, nb_paths, nb_params) + + +def test_FeAu_JADB_bb_friedel(): + proc_dir = '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/PROCESSED_DATA/20250127_JADB/friedel' + nb_names = [ + '0_segment_frelon.ipynb', + '1_index_friedel.ipynb', + '2_merge_slices.ipynb' + ] + sample = 'FeAu_0p5_tR' + dataset = 'ff1' # first of two layers + dset_file = os.path.join(proc_dir, sample, f'{sample}_{dataset}', f'{sample}_{dataset}_dataset.h5') + bgfile = None + maskfile = '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/mask.edf' + nb_params = [ + {'PYTHONPATH': sys.path[0], # 0_segment_frelon.ipynb + 'splinefile': ['/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/frelon36_spline_20240604_dx.edf','/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/frelon36_spline_20240604_dy.edf'], + 'bgfile': bgfile, + 'maskfile': maskfile, + 'detector': 'frelon3', + 'omegamotor': 'diffrz', + 'dtymotor': 'diffty', + 'options': { + "bgfile":bgfile, + "maskfile":maskfile, + "threshold":70, + "smoothsigma":1.0, + "bgc":0.9, + "minpx":3, + "m_offset_thresh":100, + "m_ratio_thresh":150, + }, + 'dataroot': '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/RAW_DATA/', + 'analysisroot': proc_dir, + 'sample': sample, + 'dataset': dataset, + 'dset_prefix': "ff" + }, + {'PYTHONPATH': sys.path[0], # 1_index_friedel.ipynb + 'dset_path': dset_file, + 'phase_str': 'Fe', + 'parfile': '/data/id11/inhouse2/test_data_3DXRD/TDXRD/FeAu/pars/pars_tdxrd.json', + 'cf_strong_frac': 0.991, + 'cf_strong_dsmax': 1.01, + 'cf_strong_dstol': 0.01, + 'womega': 1.0, + 'weta': 1.0, + 'wtth': 1.5, + 'wI': 0.5, + 'indexer_ds_tol': 0.003, + 'rings_for_gen': [1, 3], + 'rings_for_scoring': [0, 1, 2, 3], + 'hkl_tols_seq': [0.01, 0.02], + 'fracs': [0.9, 0.6], + 'max_grains': 1000, + 'symmetry': 'cubic', + 'gridpars': { + 'DSTOL' : 0.004, + 'NUL' : True, + 'FITPOS' : True, + 'tolangle' : 0.25, + 'toldist' : 100., + 'NTHREAD' : 1 , + 'NPKS': 25 + }, + 'absolute_minpks': 25, + 'dset_prefix': "ff" + }, + {'PYTHONPATH': sys.path[0], # 2_merge_slices.ipynb + 'dset_path': dset_file, + 'phase_str': 'Fe', + 'z_translation_motor': 'samtz', + 'dset_prefix': "ff" + }, + ] + nb_paths = [os.path.join(bb_nb_prefix, name) for name in nb_names] + notebook_route(proc_dir, nb_paths, nb_params) + + if __name__=='__main__': print(papermill.__path__) - test_FeAu_JADB_tomo() - test_FeAu_JADB_pbp() \ No newline at end of file + # test_FeAu_JADB_tomo() + # test_FeAu_JADB_pbp() + # test_FeAu_JADB_bb() + # test_FeAu_JADB_bb_grid() + test_FeAu_JADB_bb_friedel() \ No newline at end of file