diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 76434c4d..dc123268 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -12,24 +12,23 @@ jobs: runs-on: ${{ matrix.os}} strategy: matrix: - python-version: [ '3.8', '3.9', '3.10','3.11'] + python-version: ['3.10','3.11'] os: [ubuntu-latest, macOS-latest, windows-latest] steps: - - uses: actions/checkout@v2 + - uses: actions/checkout@v4 - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v2 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Cache pip - uses: actions/cache@v2 + uses: actions/cache@v4 with: - # This path is specific to Ubuntu - path: ~/.cache/pip + path: ${{ env.pythonLocation }} # Look to see if there is a cache hit for the corresponding requirements file - key: ${{ runner.os }}-pip-${{ hashFiles('requirements.txt') }} + key: ${{ runner.os }}-py${{ matrix.python-version }}-pip-${{ hashFiles('requirements.txt') }} restore-keys: | - ${{ runner.os }}-pip- + ${{ runner.os }}-py${{ matrix.python-version }}-pip- ${{ runner.os }}- - name: Install dependencies run: | @@ -58,6 +57,8 @@ jobs: unzip PSS300nm_C_ccd100.zip wget https://github.com/usnistgov/PyHyperScattering/releases/download/0.0.0-example-data/smi_example.zip unzip smi_example.zip + wget https://github.com/usnistgov/PyHyperScattering/releases/download/0.0.0-example-data/CMS_giwaxs_series.zip + unzip CMS_giwaxs_series.zip - name: Fetch and unzip example data (Windows) if: ${{ matrix.os == 'windows-latest' }} run: | @@ -71,7 +72,11 @@ jobs: unzip PSS300nm_C_ccd100.zip C:\msys64\usr\bin\wget.exe https://github.com/usnistgov/PyHyperScattering/releases/download/0.0.0-example-data/smi_example.zip unzip smi_example.zip + C:\msys64\usr\bin\wget.exe https://github.com/usnistgov/PyHyperScattering/releases/download/0.0.0-example-data/CMS_giwaxs_series.zip + unzip CMS_giwaxs_series.zip - name: Test with pytest + env: + TILED_API_KEY: ${{ secrets.TILED_API_KEY }} run: | #pytest -v #temporarily disabling coverage for memory usage @@ -81,7 +86,7 @@ jobs: coverage report coverage html - name: Upload coverage report - uses: actions/upload-artifact@v2 + uses: actions/upload-artifact@v4 with: name: coverage-${{ matrix.os}}-${{ matrix.python-version }}.html path: htmlcov/index.html diff --git a/.github/workflows/python-publish.yml b/.github/workflows/python-publish.yml index 11546ec9..803f572a 100644 --- a/.github/workflows/python-publish.yml +++ b/.github/workflows/python-publish.yml @@ -19,11 +19,11 @@ jobs: steps: - name: Fetch repo - uses: actions/checkout@v2 + uses: actions/checkout@v4 with: fetch-depth: 0 - name: Set up Python - uses: actions/setup-python@v2 + uses: actions/setup-python@v5 with: python-version: '3.x' - name: Install dependencies @@ -33,7 +33,7 @@ jobs: - name: Build package run: python -m build - name: Publish package - uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29 + uses: pypa/gh-action-pypi-publish@v1.8.14 with: user: __token__ password: ${{ secrets.PYPI_TOKEN }} diff --git a/.github/workflows/python-test-publish-all.yml b/.github/workflows/python-test-publish-all.yml index b4d46991..696003b3 100644 --- a/.github/workflows/python-test-publish-all.yml +++ b/.github/workflows/python-test-publish-all.yml @@ -22,11 +22,11 @@ jobs: if: ${{ github.event.workflow_run.conclusion == 'success' }} steps: - name: Fetch repo - uses: actions/checkout@v2 + uses: actions/checkout@v4 with: fetch-depth: 0 - name: Set up Python - uses: actions/setup-python@v2 + uses: actions/setup-python@v5 with: python-version: '3.x' - name: Install dependencies @@ -39,7 +39,7 @@ jobs: - name: Build package run: python -m build - name: Publish package - uses: pypa/gh-action-pypi-publish@27b31702a0e7fc50959f5ad993c78deac1bdfc29 + uses: pypa/gh-action-pypi-publish@v1.8.14 with: user: __token__ password: ${{ secrets.TEST_PYPI_TOKEN }} diff --git a/.gitignore b/.gitignore index 4694f5b1..48b0766d 100755 --- a/.gitignore +++ b/.gitignore @@ -12,10 +12,10 @@ venv/* OrientationRunDec2019/** **/*.p **/.* -**/*.ipynb *.png *.h5 *.nxs +.ipynb_checkpoints Example/** example-data/** src/__pycache__ @@ -23,7 +23,7 @@ src/__pycache__ src/PyHyperScattering/__pycache__ src/PyHyperScattering/.ipynb_checkpoints/* dist -docs/_build/* +dcs/_build/* docs/_build/html/* *.pyc example_data/11012/Dark_56367-AI.txt diff --git a/pyproject.toml b/pyproject.toml index 374b58cb..4b5c198a 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,100 @@ [build-system] -requires = [ - "setuptools>=42", - "wheel" -] +requires = ["setuptools", "wheel", "versioneer[toml]"] build-backend = "setuptools.build_meta" + +[project] +name = "PyHyperScattering" +dynamic = ["version"] +authors = [ + {name = "Peter Beaucage", email = "peter.beaucage@nist.gov"}, +] +description = "Utilities for loading, reducing, fitting, and plotting hyperspectral x-ray and neutron scattering data." +readme = "README.md" +requires-python = ">=3.6" +classifiers = [ + "Programming Language :: Python :: 3", + "License :: OSI Approved :: MIT License", + "Operating System :: OS Independent", + "Development Status :: 3 - Alpha", + "Intended Audience :: Science/Research", + "License :: Freely Distributable", + "Topic :: Scientific/Engineering :: Chemistry", + "Topic :: Scientific/Engineering :: Physics", +] +dependencies = [ + "h5py", + "numpy<2", + "pandas", + "pyfai", + "pyopencl", + "scikit-image", + "scipy", + "pillow", + "xarray", + "tqdm", + "astropy", + "fabio", + "nodejs", + "silx==2.0.0", + "pygix", + "pydata_sphinx_theme", + "numexpr<2.8.5", +] + +[project.optional-dependencies] +bluesky = [ + "tiled[all]>=0.1.0a74", + "databroker[all]>=2.0.0b10", + "bottleneck" +] +performance = [ + "pyopencl", + "dask", + "cupy" +] +ui = [ + "holoviews==1.16.2", + "hvplot" +] +doc = [ + "sphinx", + "pydata_sphinx_theme" + ] +test = [ + "pytest", + "black", + "codecov", + "pylint" + ] +all = [ + "tiled[all]>=0.1.0a74", + "databroker[all]>=2.0.0b10", + "bottleneck", + "pyopencl", + "dask", + "cupy", + "holoviews==1.16.2", + "hvplot", + "sphinx", + "pydata_sphinx_theme", + "pytest", + "black", + "codecov", + "pylint" +] + +[project.urls] +"Homepage" = "https://github.com/usnistgov/pyhyperscattering" +"Bug Tracker" = "https://github.com/usnistgov/pyhyperscattering/issues" +"Project Site" = "https://www.nist.gov/laboratories/tools-instruments/polarized-resonant-soft-x-ray-scattering-p-rsoxs" + +[tool.setuptools.packages.find] +where = ["src"] + +[tool.versioneer] +VCS = "git" +style = "pep440" +versionfile_source = "src/PyHyperScattering/_version.py" +versionfile_build = "PyHyperScattering/_version.py" +tag_prefix = "" +parentdir_prefix = "pyhyperscattering-" diff --git a/requirements-bluesky.txt b/requirements-bluesky.txt index 594caea8..d7471fc2 100644 --- a/requirements-bluesky.txt +++ b/requirements-bluesky.txt @@ -1,2 +1,3 @@ -tiled[client]>=0.1.0a74 +tiled[all]>=0.1.0a74 databroker[all]>=2.0.0b10 +bottleneck diff --git a/requirements.txt b/requirements.txt index d34ce394..6107d9d1 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,9 +3,12 @@ astropy fabio h5py nodejs -numpy +numpy<2 pandas +# pygix fails to improt if silx > 2.0.0 +silx==2.0.0 pyfai +pygix scikit-image scipy pillow diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index 59011d9a..00000000 --- a/setup.cfg +++ /dev/null @@ -1,48 +0,0 @@ -[metadata] -name = PyHyperScattering -version = attr: PyHyperScattering.__version__ -author = Peter Beaucage -author_email = peter.beaucage@nist.gov -description = Utilities for loading, reducing, fitting, and plotting hyperspectral x-ray and neutron scattering data. -long_description = file: README.md -long_description_content_type = text/markdown -url = https://github.com/usnistgov/pyhyperscattering -project_urls = - Github = https://github.com/usnistgov/pyhyperscattering - Project Site = https://www.nist.gov/laboratories/tools-instruments/polarized-resonant-soft-x-ray-scattering-p-rsoxs -classifiers = - Programming Language :: Python :: 3 - License :: OSI Approved :: MIT License - Operating System :: OS Independent - Development Status :: 3 - Alpha - Intended Audience :: Science/Research - License :: Freely Distributable - Topic :: Scientific/Engineering :: Chemistry - Topic :: Scientific/Engineering :: Physics - -[options] -package_dir = - = src -packages = find: -python_requires = >=3.6 -install_requires = - h5py - numpy - pandas - pyfai - pyopencl - scikit-image - scipy - pillow - xarray - tqdm -[options.packages.find] -where = src - -[versioneer] -VCS = git -style = pep440 -versionfile_source = src/PyHyperScattering/_version.py -versionfile_build = PyHyperScattering/_version.py -tag_prefix = -parentdir_prefix = pyhyperscattering- diff --git a/src/PyHyperScattering/CMSGIWAXSLoader.py b/src/PyHyperScattering/CMSGIWAXSLoader.py new file mode 100644 index 00000000..18b84f97 --- /dev/null +++ b/src/PyHyperScattering/CMSGIWAXSLoader.py @@ -0,0 +1,319 @@ +import pathlib +import warnings +import fabio +from PIL import Image +from PyHyperScattering.FileLoader import FileLoader +import xarray as xr +import pandas as pd +import numpy as np +from tqdm.auto import tqdm + +class CMSGIWAXSLoader(FileLoader): + """ + GIXS Data Loader Class | NSLS-II 11-BM (CMS) + Used to load single TIFF time-series TIFF GIWAXS images. + """ + def __init__(self, md_naming_scheme=[], root_folder=None, delim='_'): + """ + Inputs: md_naming_scheme: A list of attribute names to load from + filename, which is split by the delimeter argument (default is + '_'). If no list is provided, the filename will be loaded an + an attribute. + + root_folder: not implemented yet, to use with future helper functions + + delim: delimeter value to split filename (default is underscore) + """ + + self.md_naming_scheme = md_naming_scheme + if len(md_naming_scheme) == 0: + warnings.warn('Provided an empty md_naming_scheme. This will just load the filename as an attribute.',stacklevel=2) + self.root_folder = root_folder + self.delim = delim + self.sample_dict = None + self.selected_series = [] + + def loadSingleImage(self, filepath,coords=None,return_q=False,image_slice=None,use_cached_md=False,**kwargs): + """ + Loads a single xarray DataArray from a filepath to a raw TIFF + + Inputs: + - filepath: str or pathlib.Path to image to load + + Unused inputs (for loadFileSeries compatability): + - coords + - return_q + - image_slice + - use_cached_md + + """ + + # Ensure that the path exists before continuing. + filepath = pathlib.Path(filepath) + + # Open the image from the filepath + # Get the file extension using pathlib + file_extension = filepath.suffix.lower() + + # Choose the appropriate method based on the file extension + if file_extension in ['.tiff', '.tif']: + # Load using PIL for tiffs, just to avoid a warning message + image_data = np.array(Image.open(filepath)) + else: + # Default for Load using Fabio + image_data = fabio.open(filepath).data + + # Run the loadMetaData method to construct the attribute dictionary for the filePath. + attr_dict = self.loadMd(filepath) + + # Convert the image numpy array into an xarray DataArray object. + image_da = xr.DataArray(data = image_data, + dims = ['pix_y', 'pix_x'], + attrs = attr_dict) + + image_da = image_da.assign_coords({ + 'pix_x': image_da.pix_x.data, + 'pix_y': image_da.pix_y.data + }) + return image_da + + def loadMd(self, filepath): + """ + Description: Uses metadata_keylist to generate attribute dictionary of metadata based on filename. + Input Variables + filepath : string + Filepath passed to the loadMetaData method that is used to extract metadata relevant to the TIFF image. + + + """ + delim = self.delim + attr_dict = {} # Attributes dictionary of metadata attributes created using the filename and metadata list passed during initialization. + name = filepath.name # # strip the filename from the filePath + md_list = name.split(delim) # splits the filename based on the delimiter passed to the loadMd method. + # Metadata list - list of metadata keys used to segment the filename into a dictionary corresponding to said keys. + + if len(self.md_naming_scheme) == 0: + attr_dict['filename'] = name + elif len(self.md_naming_scheme) >= 1: + for i, md_item in enumerate(self.md_naming_scheme): + attr_dict[md_item] = md_list[i] + return attr_dict + + def loadSeries(self, files, filter='', time_start=0): + """ + LEGACY METHOD: PyHyperScattering.load.loadFileSeries() will be the updated method moving forward + + Load many raw TIFFs into an xarray DataArray + + Input: files: Either a pathlib.Path object that can be filtered with a + glob filter or an iterable that contains the filepaths + Output: xr.DataArray with appropriate dimensions & coordinates + """ + + data_rows = [] + if issubclass(type(files), pathlib.Path): + for filepath in tqdm(files.glob(f'*{filter}*'), desc='Loading raw GIWAXS time slices'): + image_da = self.loadSingleImage(filepath) + image_da = image_da.assign_coords({'series_number': int(image_da.series_number)}) + image_da = image_da.expand_dims(dim={'series_number': 1}) + data_rows.append(image_da) + else: + try: + for filepath in tqdm(files, desc='Loading raw GIWAXS time slices'): + image_da = self.loadSingleImage(filepath) + image_da = image_da.assign_coords({'series_number': int(image_da.series_number)}) + image_da = image_da.expand_dims(dim={'series_number': 1}) + data_rows.append(image_da) + except TypeError as e: + raise TypeError('"files" needs to be a pathlib.Path or iterable') from e + + out = xr.concat(data_rows, 'series_number') + out = out.sortby('series_number') + out = out.assign_coords({ + 'series_number': out.series_number.data, + 'time': ('series_number', + out.series_number.data*np.round(float(out.exposure_time[:-1]), + 1)+np.round(float(out.exposure_time[:-1]),1)+time_start) + }) + out = out.swap_dims({'series_number': 'time'}) + out = out.sortby('time') + del out.attrs['series_number'] + + return out + + def createSampleDictionary(self, root_folder): + """ + NOT FULLY IMPLEMENTED YET + + Loads and creates a sample dictionary from a root folder path. + The dictionary will contain: sample name, scanID list, series scanID list, + a pathlib object variable for each sample's data folder (which contains the /maxs/raw/ subfolders), + and time_start and exposure_time for each series of scans. + + The method uses alias mappings to identify important metadata from the filenames: + SCAN ID : Defines the scan ID number in the convention used at 11-BM (CMS), specific to a single shot exposure or time series. + aliases : scan_id: 'scanid', 'id', 'scannum', 'scan', 'scan_id', 'scan_ID' + SERIES NUMBER : Within a series (fixed SCAN ID), the exposure number in the series with respect to the starting TIME START (clocktime) + aliases : series_number: 'seriesnum', 'seriesid', 'series_id', 'series_ID', 'series', 'series_number', 'series_num' + TIME START : Also generically referred to as CLOCK TIME, logs the start of the exposure or series acquisition. This time is constant for all exposures within a series. + aliases : time_start: 'start_time', 'starttime', 'start', 'clocktime', 'clock', 'clockpos', 'clock_time', 'time', 'time_start' + EXPOSURE TIME : The duration of a single shot or exposure, either in a single image or within a series. + aliases : 'exptime', 'exp_time', 'exposuretime', 'etime', 'exp', 'expt', 'exposure_time' + """ + + # Ensure the root_folder is a pathlib.Path object + self.root_folder = pathlib.Path(root_folder) + if not self.root_folder.is_dir(): + raise ValueError(f"Directory {self.root_folder} does not exist.") + + # Initialize the sample dictionary + sample_dict = {} + + # Alias mappings for scan_id, series_number, time_start, and exposure_time + scan_id_aliases = ['scanid', 'id', 'scannum', 'scan', 'scan_id', 'scan_ID'] + series_number_aliases = ['seriesnum', 'seriesid', 'series_id', 'series_ID', 'series', 'series_number', 'series_num'] + time_start_aliases = ['start_time', 'starttime', 'start', 'clocktime', 'clock', 'clockpos', 'clock_time', 'time', 'time_start'] + exposure_time_aliases = ['exptime', 'exp_time', 'exposuretime', 'etime', 'exp', 'expt', 'exposure_time'] + + # Identify the indices of the required metadata in the naming scheme + for idx, alias in enumerate(self.md_naming_scheme): + if alias.lower() in [alias.lower() for alias in scan_id_aliases]: + self.scan_id_index = idx + if alias.lower() in [alias.lower() for alias in series_number_aliases]: + self.series_number_index = idx + + if self.scan_id_index is None or self.series_number_index is None: + raise ValueError('md_naming_scheme does not contain keys for scan_id or series_number.') + + # Update sample_dict with new information + for sample_folder in self.root_folder.iterdir(): + if sample_folder.is_dir(): + # Confirm that this is a sample folder by checking for /maxs/raw/ subfolder + maxs_raw_dir = sample_folder / 'maxs' / 'raw' + if maxs_raw_dir.is_dir(): + # Sample folder checks out, extract scan_id, series_number, time_start, and exposure_time + sample_name = sample_folder.name + scan_list = [] + series_list = {} # Initialize series_list as an empty dictionary + + for image_file in maxs_raw_dir.glob('*'): + # Load metadata from image + metadata = self.loadMd(image_file) + + # Lowercase all metadata keys for case insensitivity + metadata_lower = {k.lower(): v for k, v in metadata.items()} + + # Find and store scan_id, series_number, time_start, and exposure_time + scan_id = metadata_lower.get(self.md_naming_scheme[self.scan_id_index].lower()) + series_number = metadata_lower.get(self.md_naming_scheme[self.series_number_index].lower()) + time_start = next((metadata_lower[key] for key in metadata_lower if key in time_start_aliases), None) + exposure_time = next((metadata_lower[key] for key in metadata_lower if key in exposure_time_aliases), None) + + # Add them to our lists + scan_list.append(scan_id) + + # Check if scan_id is in series_list, if not, create a new list + if scan_id not in series_list: + series_list[scan_id] = [] + + series_list[scan_id].append((series_number, time_start, exposure_time)) + + # Store data in dictionary + sample_dict[sample_name] = { + 'scanlist': scan_list, + 'serieslist': series_list, + 'path': sample_folder + } + + self.sample_dict = sample_dict + return sample_dict + + def selectSampleAndSeries(self): + """ + NOT FULLY IMPLEMENTED YET + + Prompts the user to select a sample and one or more series of scans from that sample. + The user can choose to select all series of scans. + The selections will be stored as the 'selected_series' attribute and returned. + """ + # Check if sample_dict has been generated + if not self.sample_dict: + print("Error: Sample dictionary has not been generated. Please run createSampleDictionary() first.") + return + + while True: + # Show the user a list of sample names and get their selection + print("Please select a sample (or 'q' to exit):") + sample_names = list(self.sample_dict.keys()) + for i, sample_name in enumerate(sample_names, 1): + print(f"[{i}] {sample_name}") + print("[q] Exit") + selection = input("Enter the number of your choice: ") + if selection.lower() == 'q': + print("Exiting selection.") + return self.selected_series + else: + sample_index = int(selection) - 1 + selected_sample = sample_names[sample_index] + + # Show the user a choice between single image or image series and get their selection + print("\nWould you like to choose a single image or an image series? (or 'q' to exit)") + print("[1] Single Image") + print("[2] Image Series") + print("[q] Exit") + choice = input("Enter the number of your choice: ") + if choice.lower() == 'q': + print("Exiting selection.") + return self.selected_series + choice = int(choice) + + # Get the selected sample's scan list and series list + scan_list = self.sample_dict[selected_sample]['scanlist'] + series_list = self.sample_dict[selected_sample]['serieslist'] + + # Identify series scan IDs and single image scan IDs + series_scan_ids = set(series_list.keys()) + single_image_scan_ids = [scan_id for scan_id in scan_list if scan_id not in series_scan_ids] + + if choice == 1: + # The user has chosen to select a single image + print("\nPlease select a scan ID (or 'q' to exit):") + for i, scan_id in enumerate(single_image_scan_ids, 1): + print(f"[{i}] {scan_id}") + print("[q] Exit") + selection = input("Enter the number of your choice: ") + if selection.lower() == 'q': + print("Exiting selection.") + return self.selected_series + else: + scan_id_index = int(selection) - 1 + selected_scan = single_image_scan_ids[scan_id_index] + self.selected_series.append((selected_sample, selected_scan)) + else: + # The user has chosen to select an image series + print("\nPlease select one or more series (Enter 'a' to select all series, 'q' to finish selection):") + selected_series = [] + while True: + for i, series_scan_id in enumerate(series_scan_ids, 1): + series_data = series_list[series_scan_id] + print(f"[{i}] Series {series_scan_id} (start time: {series_data[0][1]}, exposure time: {series_data[0][2]})") + print("[a] All series") + print("[q] Finish selection") + selection = input("Enter the number(s) of your choice (comma-separated), 'a', or 'q': ") + if selection.lower() == 'q': + if selected_series: + break + else: + print("Exiting selection.") + return self.selected_series + elif selection.lower() == 'a': + selected_series = list(series_scan_ids) + break + else: + # Get the series indices from the user's input + series_indices = list(map(int, selection.split(','))) + selected_series += [list(series_scan_ids)[i-1] for i in series_indices] + self.selected_series.extend([(selected_sample, series) for series in selected_series]) + + print("\nSelection completed.") + return self.selected_series diff --git a/src/PyHyperScattering/FileIO.py b/src/PyHyperScattering/FileIO.py index 1229a94c..816c7165 100644 --- a/src/PyHyperScattering/FileIO.py +++ b/src/PyHyperScattering/FileIO.py @@ -34,7 +34,25 @@ def __init__(self,xr_obj): def savePickle(self,filename): with open(filename, 'wb') as file: pickle.dump(self._obj, file) - + + + # - This was copied from the Toney group contribution for GIWAXS. + def saveZarr(self, filename, mode: str = 'w'): + """ + Save the DataArray as a .zarr file in a specific path, with a file name constructed from a prefix and suffix. + + Parameters: + da (xr.DataArray): The DataArray to be saved. + base_path (Union[str, pathlib.Path]): The base path to save the .zarr file. + prefix (str): The prefix to use for the file name. + suffix (str): The suffix to use for the file name. + mode (str): The mode to use when saving the file. Default is 'w'. + """ + da = self._obj + ds = da.to_dataset(name='DA') + file_path = pathlib.Path(filename) + ds.to_zarr(file_path, mode=mode) + def saveNexus(self,fileName,compression=5): data = self._obj timestamp = datetime.datetime.now() diff --git a/src/PyHyperScattering/FileLoader.py b/src/PyHyperScattering/FileLoader.py index 34f13255..2c2d09ac 100755 --- a/src/PyHyperScattering/FileLoader.py +++ b/src/PyHyperScattering/FileLoader.py @@ -14,13 +14,12 @@ class FileLoader(): Abstract class defining a generic scattering file loader. Input is a (or multiple) filename/s and output is a xarray I(pix_x,pix_y,dims,coords) where dims and coords are loaded by user request. - - Difference: all coords are dims but not all dims are coords. Dims can also be auto-hinted using the following - standard names: energy,exposure,pos_x,pos_y,pos_z,theta. + Difference: all coords are dims but not all dims are coords. Dims can also be auto-hinted using the following + standard names: energy,exposure,pos_x,pos_y,pos_z,theta. - Individual loaders can try searching metadata for other dim names but this is not guaranteed. - Coords can be used to provide a list of values for a dimension when that dimension cannot be hinted, e.g. where vals - come from external data. + Individual loaders can try searching metadata for other dim names but this is not guaranteed. + Coords can be used to provide a list of values for a dimension when that dimension cannot be hinted, e.g. where vals + come from external data. ''' file_ext = '' # file extension to be used to filter files from this instrument md_loading_is_quick = False @@ -32,20 +31,35 @@ def loadSingleImage(self,filepath,coords=None,return_q=None,**kwargs): def peekAtMd(self,filepath): return self.loadSingleImage(filepath,{}) - - - def loadFileSeries(self,basepath,dims,coords={},file_filter=None,file_filter_regex=None,file_skip=None,md_filter={},quiet=True,output_qxy=False,dest_qx=None,dest_qy=None,output_raw=False,image_slice=None): + def loadFileSeries(self, + basepath, + dims, + coords={}, + file_filter=None, + file_filter_regex=None, + file_skip=None, + md_filter={}, + quiet=True, + output_qxy=False, + dest_qx=None, + dest_qy=None, + output_raw=False, + image_slice=None): ''' Load a series into a single xarray. + * = not implemented yet + Args: basepath (str or Path): path to the directory to load - dims (list): dimensions of the resulting xarray, as list of str + dims (list): dimensions of the resulting xarray (excluding 'pix_x' and 'pix_y'), as list of str coords (dict): dictionary of any dims that are *not* present in metadata file_filter (str): string that must be in each file name - file_filer_regex(str): regex string that must match in each file name - file_skip (str): string that, if present in file name, means file should be skipped. + + *file_filer_regex(str): regex string that must match in each file name + *file_skip (str): string that, if present in file name, means file should be skipped. + md_filter (dict): dict of *required* metadata values; points without these metadata values will be dropped md_filter_regex (dict): dict of *required* metadata regex; points without these metadata values will be dropped quiet (bool): skip printing most intermediate output if true. @@ -61,14 +75,20 @@ def loadFileSeries(self,basepath,dims,coords={},file_filter=None,file_filter_reg nfiles = len(os.listdir(basepath)) nprocessed = 0 nloaded = 0 - print(f'Found {str(nfiles)} files.') + print(f'Found {str(nfiles)} total files.') data_rows = [] qnew = None dest_coords = defaultdict(list) if file_filter_regex is not None: file_filter_regex = re.compile(file_filter_regex) - - for file in tqdm(sorted(os.listdir(basepath))): + if file_filter is not None: + filepaths = sorted(basepath.glob(f'*{file_filter}*')) + files = [f.name for f in filepaths] + else: + files = sorted(os.listdir(basepath)) + print(f"Found {str(len(files))} files after applying 'file_filter'.") + + for file in tqdm(files): nprocessed += 1 if re.match(self.file_ext,file) is None: @@ -102,7 +122,7 @@ def loadFileSeries(self,basepath,dims,coords={},file_filter=None,file_filter_reg if not quiet: print(f'Not loading {file}, expected {key} to be {val} but it was {md[key]}') if load_this_image: - if img == None: + if img is None: if not quiet: print(f'Loading {file}') img = self.loadSingleImage(basepath/file,coords=local_coords, return_q = output_qxy,image_slice=image_slice,use_cached_md=False) diff --git a/src/PyHyperScattering/IntegrationUtils.py b/src/PyHyperScattering/IntegrationUtils.py index 1ad1c537..ba804072 100644 --- a/src/PyHyperScattering/IntegrationUtils.py +++ b/src/PyHyperScattering/IntegrationUtils.py @@ -2,6 +2,7 @@ import xarray as xr import numpy as np import math +from tqdm.auto import tqdm try: import holoviews as hv @@ -98,6 +99,8 @@ def checkAll(integrator,img,img_min=1,img_max=10000,img_scaling='log',alpha=1,d_ ax.add_patch(guide1) ax.add_patch(guide2) ax.imshow(integrator.mask,origin='lower',alpha=alpha) + + class DrawMask: ''' Utility class for interactively drawing a mask in a Jupyter notebook. @@ -114,21 +117,22 @@ class DrawMask: ''' - def __init__(self,frame): + def __init__(self,frame, cmap='viridis', clim=(5e0, 5e3), width=800, height=700): ''' Construct a DrawMask object Args: frame (xarray): a single data frame with pix_x and pix_y axes - ''' + if len(frame.shape) > 2: warnings.warn('This tool needs a single frame, not a stack! .sel down to a single frame before starting!',stacklevel=2) - self.frame=frame + self.frame = frame - self.fig = frame.hvplot(cmap='terrain',clim=(5,5000),logz=True,data_aspect=1) + self.fig = frame.hvplot(cmap=cmap, clim=clim, logz=True, data_aspect=1, + width=width, height=height) self.poly = hv.Polygons([]) self.path_annotator = hv.annotate.instance() @@ -140,17 +144,13 @@ def ui(self): Returns: the holoviews object - - ''' print('Usage: click the "PolyAnnotator" tool at top right. DOUBLE CLICK to start drawing a masked object, SINGLE CLICK to add a vertex, then DOUBLE CLICK to finish. Click/drag individual vertex to adjust.') - return self.path_annotator( - self.fig * self.poly.opts( - width=self.frame.shape[0], - height=self.frame.shape[1], - responsive=False), - annotations=['Label'], - vertex_annotations=['Value']) + annotator_plot = self.path_annotator( + self.fig * self.poly.opts(responsive=False), + annotations=['Label'], + vertex_annotations=['Value']) + return annotator_plot.opts(toolbar='left') def save(self,fname): @@ -178,11 +178,11 @@ def load(self,fname): ''' with open(fname,'r') as f: strlist = json.load(f) - print(strlist) + # print(strlist) dflist = [] for item in strlist: dflist.append(pd.read_json(item)) - print(dflist) + # print(dflist) self.poly = hv.Polygons(dflist) self.path_annotator( @@ -204,3 +204,58 @@ def mask(self): mask |= skimage.draw.polygon2mask(self.frame.shape,self.path_annotator.annotated.iloc[i].dframe(['x','y'])) return mask + + +class CMSGIWAXS: + """For streamlined loading for CMS data""" + def __init__(self, files, loader, integrator): + """ + Inputs: files: indexable object str or pathlib.Path filepaths to + raw GIWAXS data + loader: custom PyHyperScattering CMSGIWAXSLoader object, must + return DataArray with attributes metadata + integrator: instance of PGGeneralIntegrator object + """ + self.files = files + self.loader = loader + self.integrator = integrator + + def single_images_to_dataset(self): + """ + Method that takes a subscriptable object of filepaths corresponding to raw GIWAXS + beamline data, loads the raw data into an xarray DataArray, generates pygix-transformed + cartesian and polar DataArrays, and creates 3 corresponding xarray Datasets + containing a DataArray per sample. + The raw dataarrays must contain the attributes 'scan_id' and 'incident_angle' + + Outputs: 2 Datasets: raw & reciprocal space (cartesian or polar based on integrator object) + """ + # Select the first element of the sorted set outside of the for loop to initialize the xr.DataSet + DA = self.loader.loadSingleImage(self.files[0]) + assert 'scan_id' in DA.attrs.keys(), "'scan_id' is a required attribute to use this function" + + # Update incident angle per sample: + assert 'incident_angle' in DA.attrs.keys(), "'incident_angle' is a required attribute to use this function" + self.integrator.incident_angle = float(DA.incident_angle[2:]) + + # Integrate single image + integ_DA = self.integrator.integrateSingleImage(DA) + + # Save coordinates for interpolating other dataarrays + integ_coords = integ_DA.coords + + # Create a DataSet, each DataArray will be named according to it's scan id + raw_DS = DA.to_dataset(name=DA.scan_id) + integ_DS = integ_DA.to_dataset(name=DA.scan_id) + + # Populate the DataSet with + for filepath in tqdm(self.files[1:], desc=f'Transforming Raw Data'): + DA = self.loader.loadSingleImage(filepath) + integ_DA = self.integrator.integrateSingleImage(DA) + + integ_DA = integ_DA.interp(integ_coords) + + raw_DS[f'{DA.scan_id}'] = DA + integ_DS[f'{DA.scan_id}'] = integ_DA + + return raw_DS, integ_DS diff --git a/src/PyHyperScattering/PFGeneralIntegrator.py b/src/PyHyperScattering/PFGeneralIntegrator.py index f7bb0bc1..ea008871 100755 --- a/src/PyHyperScattering/PFGeneralIntegrator.py +++ b/src/PyHyperScattering/PFGeneralIntegrator.py @@ -1,5 +1,6 @@ from pyFAI import azimuthalIntegrator from pyFAI.units import eq_q, formula_q, register_radial_unit +from pyFAI.io.ponifile import PoniFile import h5py import warnings import xarray as xr @@ -11,6 +12,7 @@ from skimage import draw import json import pandas as pd +import fabio # tqdm.pandas() # the following block monkey-patches xarray to add tqdm support. This will not be needed once tqdm v5 releases. @@ -46,6 +48,113 @@ def wrapper(*args, **kwargs): class PFGeneralIntegrator: + """PyFAI general integrator wrapper""" + + def __init__(self, + maskmethod = 'none', + maskrotate = True, + geomethod = 'none', + NIdistance = 0, NIbcx = 0, NIbcy = 0, NItiltx = 0, NItilty = 0, + NIpixsizex = 0, NIpixsizey = 0, + template_xr = None, + ponifile = None, + energy = 2000, + integration_method = 'csr_ocl', + correctSolidAngle = True, + maskToNan = True, + npts = 500, + use_log_ish_binning = False, + do_1d_integration = False, + return_sigma = False, + use_chunked_processing = False, + **kwargs): + + """ + General pyFAI-wrapped integrator class + + Some Inputs: + maskmethod (str, default = 'none'): What type of mask to load + options: [nika, polygon, image, pyhyper, edf, numpy, none] + + geomethod (str, default = 'none'): where to get calibration information + from for integrators + options: ['nika', 'template_xr', 'ponifile', 'none'] + + template_xr (xr.DataArray): xarray for example shape for empty masks, + and attributes for calibration if geomethod='template_xr' + + ponifile (str or pathlib.Path): + + Important keyword arguments: + maskpath (str or pathlib.Path): path to mask, if specifed a method that + requires a file + mask (numpy.ndarray): if maskmethod is 'numpy', supply an array mask + """ + + if maskmethod == 'nika': + self.loadNikaMask(rotate_image=maskrotate, **kwargs) + elif maskmethod == 'polygon': + self.loadPolyMask(**kwargs) + elif maskmethod == 'image': + self.loadImageMask(maskrotate=maskrotate, **kwargs) + elif maskmethod == 'pyhyper': + self.loadPyHyperMask(**kwargs) + elif maskmethod == 'edf': + self.loadEdfMask(**kwargs) + elif maskmethod == 'numpy': + self.mask = kwargs['mask'] + elif maskmethod == 'none': + self.mask = None + else: + raise ValueError(f'Invalid or unsupported maskmethod {maskmethod}.') + self.dist = 0.1 + self.poni1 = 0 + self.poni2 = 0 + self.rot1 = 0 + self.rot2 = 0 + self.rot3 = 0 + self.pixel1 = 0 / 1e3 + self.pixel2 = 0 / 1e3 + self.correctSolidAngle = correctSolidAngle + self.integration_method = integration_method + self._energy = energy + self.npts = npts + self.use_log_ish_binning = use_log_ish_binning + self.do_1d_integration = do_1d_integration + if self.use_log_ish_binning: + register_radial_unit( + "arcsinh(q.µm)", + scale=1.0, + label=r"arcsinh($q$.µm)", + formula="arcsinh(4.0e-6*π/λ*sin(arctan2(sqrt(x**2 + y**2), z)/2.0))", + ) + + self.maskToNan = maskToNan + self.return_sigma = return_sigma + self.use_chunked_processing = use_chunked_processing + # self._energy = 0 + if geomethod == "nika": + self.ni_pixel_x = NIpixsizex + self.ni_pixel_y = NIpixsizey + self.ni_distance = NIdistance + self.ni_beamcenter_x = NIbcx + self.ni_beamcenter_y = NIbcy + self.ni_tilt_x = NItiltx + self.ni_tilt_y = NItilty + elif geomethod == 'template_xr': + self.calibrationFromTemplateXRParams(template_xr) + elif geomethod == 'ponifile': + self.calibrationFromPoniFile(ponifile) + elif geomethod == "none": + warnings.warn( + 'Initializing geometry with default values. This is probably NOT what you want.', + stacklevel=2, + ) + + self.recreateIntegrator() + + def __str__(self): + return f"PyFAI general integrator wrapper SDD = {self.dist} m, poni1 = {self.poni1} m, poni2 = {self.poni2} m, rot1 = {self.rot1} rad, rot2 = {self.rot2} rad" def integrateSingleImage(self, img): if type(img) == xr.Dataset: @@ -188,6 +297,8 @@ def integrateSingleImage(self, img): attrs=img.attrs, ) if self.return_sigma: + sigma = xr.ones_like(res) + sigma.values = frame.sigma res = res.to_dataset(name='I') res['dI'] = sigma return res @@ -324,92 +435,7 @@ def integrateImageStack_dask(self, data, chunksize=5): integ_fly = data.map_blocks(self.integrateImageStack_legacy, template=template) if dim_to_chunk == 'pyhyper_internal_multiindex': integ_fly = integ_fly.unstack('pyhyper_internal_multiindex') - return integ_fly - - def __init__( - self, - maskmethod='none', - maskpath='', - maskrotate=True, - geomethod="none", - NIdistance=0, - NIbcx=0, - NIbcy=0, - NItiltx=0, - NItilty=0, - NIpixsizex=0, - NIpixsizey=0, - template_xr=None, - energy=2000, - integration_method='csr_ocl', - correctSolidAngle=True, - maskToNan=True, - npts=500, - use_log_ish_binning=False, - do_1d_integration=False, - return_sigma=False, - use_chunked_processing=False, - **kwargs, - ): - # energy units eV - if maskmethod == 'nika': - self.loadNikaMask(filetoload=maskpath, rotate_image=maskrotate, **kwargs) - elif maskmethod == 'polygon': - self.loadPolyMask(**kwargs) - elif maskmethod == 'image': - self.loadImageMask(maskpath=maskpath, maskrotate=maskrotate, **kwargs) - elif maskmethod == 'pyhyper': - self.loadPyHyperSavedMask(**kwargs) - elif maskmethod == 'none': - self.mask = None - else: - raise ValueError(f'Invalid or unsupported maskmethod {maskmethod}.') - self.dist = 0.1 - self.poni1 = 0 - self.poni2 = 0 - self.rot1 = 0 - self.rot2 = 0 - self.rot3 = 0 - self.pixel1 = 0 / 1e3 - self.pixel2 = 0 / 1e3 - self.correctSolidAngle = correctSolidAngle - self.integration_method = integration_method - self._energy = energy - self.npts = npts - self.use_log_ish_binning = use_log_ish_binning - self.do_1d_integration = do_1d_integration - if self.use_log_ish_binning: - register_radial_unit( - "arcsinh(q.µm)", - scale=1.0, - label=r"arcsinh($q$.µm)", - formula="arcsinh(4.0e-6*π/λ*sin(arctan2(sqrt(x**2 + y**2), z)/2.0))", - ) - - self.maskToNan = maskToNan - self.return_sigma = return_sigma - self.use_chunked_processing = use_chunked_processing - # self._energy = 0 - if geomethod == "nika": - self.ni_pixel_x = NIpixsizex - self.ni_pixel_y = NIpixsizey - self.ni_distance = NIdistance - self.ni_beamcenter_x = NIbcx - self.ni_beamcenter_y = NIbcy - self.ni_tilt_x = NItiltx - self.ni_tilt_y = NItilty - elif geomethod == 'template_xr': - self.calibrationFromTemplateXRParams(template_xr) - elif geomethod == "none": - warnings.warn( - 'Initializing geometry with default values. This is probably NOT what you want.', - stacklevel=2, - ) - - self.recreateIntegrator() - - def __str__(self): - return f"PyFAI general integrator wrapper SDD = {self.dist} m, poni1 = {self.poni1} m, poni2 = {self.poni2} m, rot1 = {self.rot1} rad, rot2 = {self.rot2} rad" + return integ_fly def integrateImageStack(self, img_stack, method=None, chunksize=None): ''' ''' @@ -476,7 +502,18 @@ def loadImageMask(self, **kwargs): print(f"Imported mask with dimensions {str(np.shape(boolmask))}") self.mask = boolmask - def loadNikaMask(self, filetoload, rotate_image=True, **kwargs): + def loadEdfMask(self, **kwargs): + ''' + Loads an edf-format mask (probably from pyFAI.calib2?). + + Args: + filetoload (pathlib.Path or string): path to edf format mask + ''' + filetoload = kwargs['maskpath'] + self.mask = fabio.open(filetoload).data + + def loadNikaMask(self, rotate_image = True, **kwargs): + ''' Loads a Nika-generated HDF5 or tiff mask and converts it to an array that matches the local conventions. @@ -485,6 +522,7 @@ def loadNikaMask(self, filetoload, rotate_image=True, **kwargs): rotate_image (bool, default True): rotate image as should work ''' mask = None + filetoload = kwargs['maskpath'] if 'h5' in str(filetoload) or 'hdf' in str(filetoload): type = 'h5' @@ -526,7 +564,7 @@ def loadPyHyperMask(self, **kwargs): yval = shape.y[index] pyhyper_shape.append([xval, yval]) pyhyperlist.append(pyhyper_shape) - self.loadPolyMask(maskpoints=pyhyperlist, **kwargs) + self.loadPolyMask(maskpoints=pyhyperlist,**kwargs) def calibrationFromTemplateXRParams(self, raw_xr): ''' @@ -557,7 +595,7 @@ def calibrationFromTemplateXRParams(self, raw_xr): f'Since mask was none, creating an empty mask with shape {self.mask.shape}', stacklevel=2, ) - + if hasattr(raw_xr.energy, '__iter__'): # this is an iterable, not a single number self.energy = raw_xr.energy[0] else: @@ -565,6 +603,86 @@ def calibrationFromTemplateXRParams(self, raw_xr): self.recreateIntegrator() + def calibrationFromPoniFile(self, ponifile): + + ''' + Sets calibration from a pyFAI poni-file + + Args: + ponifile (str or Pathlib.path): a pyFAI poni file containing the geometry + raw_xr (raw format xarray): optional, raw xr with correct pixel dimensions + for creating an empty mask if necessary + ''' + ponifile = PoniFile(data=str(ponifile)) + self.dist = ponifile._dist + self.poni1 = ponifile._poni1 + self.poni2 = ponifile._poni2 + self.rot1 = ponifile._rot1 + self.rot2 = ponifile._rot2 + self.rot3 = ponifile._rot3 + self.wavelength = ponifile._wavelength + + self.pixel1 = ponifile.detector.pixel1 + self.pixel2 = ponifile.detector.pixel2 + + self.recreateIntegrator() + + def calibrationFromNikaParams(self, distance, bcx, bcy, tiltx, tilty, pixsizex, pixsizey): + ''' + DEPRECATED as of 0.2 + + Set the local calibrations using Nika parameters. + this will probably only support rotations in the SAXS limit (i.e., where sin(x) ~ x, i.e., a couple degrees) + since it assumes the PyFAI and Nika rotations are about the same origin point (which I think isn't true). + + Args: + distance: sample-detector distance in mm + bcx: beam center x in pixels + bcy: beam center y in pixels + tiltx: detector x tilt in deg, see note above + tilty: detector y tilt in deg, see note above + pixsizex: pixel size in x, microns + pixsizey: pixel size in y, microns + ''' + + self.ni_pixel_x = pixsizex + self.ni_pixel_y = pixsizey + self.ni_distance = distance + self.ni_beamcenter_x = bcx + self.ni_beamcenter_y = bcy + self.ni_tilt_x = tiltx + self.ni_tilt_y = tilty + + ''' preserved for reference + self.dist = distance / 1000 # mm in Nika, m in pyFAI + self.poni1 = bcy * pixsizey / 1000#pyFAI uses the same 0,0 definition, so just pixel to m. y = poni1, x = poni2 + self.poni2 = bcx * pixsizex / 1000 + + self.rot1 = tiltx * (math.pi/180) + self.rot2 = tilty * (math.pi/180) #degree to radian and flip x/y + self.rot3 = 0 #don't support this, it's only relevant for multi-detector geometries + + self.pixel1 = pixsizey/1e3 + self.pixel2 = pixsizex/1e3 + self.recreateIntegrator()''' + + def recreateIntegrator(self): + ''' + recreate the integrator, after geometry change + ''' + self.integrator = azimuthalIntegrator.AzimuthalIntegrator( + self.dist, + self.poni1, + self.poni2, + self.rot1, + self.rot2, + self.rot3, + pixel1=self.pixel1, + pixel2=self.pixel2, + wavelength=self.wavelength, + ) + + @property def wavelength(self): return 1.239842e-6 / self._energy # = wl ; energy = 1.239842e-6 / wl @@ -659,58 +777,3 @@ def ni_pixel_y(self, value): self.pixel1 = value / 1e3 self.ni_beamcenter_y = self.ni_beamcenter_y self.recreateIntegrator() - - def recreateIntegrator(self): - ''' - recreate the integrator, after geometry change - ''' - self.integrator = azimuthalIntegrator.AzimuthalIntegrator( - self.dist, - self.poni1, - self.poni2, - self.rot1, - self.rot2, - self.rot3, - pixel1=self.pixel1, - pixel2=self.pixel2, - wavelength=self.wavelength, - ) - - def calibrationFromNikaParams(self, distance, bcx, bcy, tiltx, tilty, pixsizex, pixsizey): - ''' - DEPRECATED as of 0.2 - - Set the local calibrations using Nika parameters. - this will probably only support rotations in the SAXS limit (i.e., where sin(x) ~ x, i.e., a couple degrees) - since it assumes the PyFAI and Nika rotations are about the same origin point (which I think isn't true). - - Args: - distance: sample-detector distance in mm - bcx: beam center x in pixels - bcy: beam center y in pixels - tiltx: detector x tilt in deg, see note above - tilty: detector y tilt in deg, see note above - pixsizex: pixel size in x, microns - pixsizey: pixel size in y, microns - ''' - - self.ni_pixel_x = pixsizex - self.ni_pixel_y = pixsizey - self.ni_distance = distance - self.ni_beamcenter_x = bcx - self.ni_beamcenter_y = bcy - self.ni_tilt_x = tiltx - self.ni_tilt_y = tilty - - ''' preserved for reference - self.dist = distance / 1000 # mm in Nika, m in pyFAI - self.poni1 = bcy * pixsizey / 1000#pyFAI uses the same 0,0 definition, so just pixel to m. y = poni1, x = poni2 - self.poni2 = bcx * pixsizex / 1000 - - self.rot1 = tiltx * (math.pi/180) - self.rot2 = tilty * (math.pi/180) #degree to radian and flip x/y - self.rot3 = 0 #don't support this, it's only relevant for multi-detector geometries - - self.pixel1 = pixsizey/1e3 - self.pixel2 = pixsizex/1e3 - self.recreateIntegrator()''' diff --git a/src/PyHyperScattering/PGGeneralIntegrator.py b/src/PyHyperScattering/PGGeneralIntegrator.py new file mode 100644 index 00000000..a18a0a24 --- /dev/null +++ b/src/PyHyperScattering/PGGeneralIntegrator.py @@ -0,0 +1,205 @@ +""" +File to: + 1. Use pygix to apply the missing wedge Ewald's sphere correction & convert to q-space + 2. Generate 2D plots of Qz vs Qxy corrected detector images + 3. Generate 2d plots of Q vs Chi images, with the option to apply the sin(chi) correction + 4. etc. +""" + +# Imports +import xarray as xr +import numpy as np +import pygix # type: ignore +import pathlib +from typing import Union, Tuple +from tqdm.auto import tqdm +import warnings +from PyHyperScattering.PFGeneralIntegrator import PFGeneralIntegrator + +class PGGeneralIntegrator(PFGeneralIntegrator): + """ + Integrator for GIWAXS data based on pygix. + + Inherits from PFGeneralIntegrator so as to benefit from its utility methods for mask loading, etc. + + + """ + def __init__(self, + inplane_config: str = 'q_xy', + sample_orientation: int = 3, + incident_angle = 0.12, + tilt_angle = 0.0, + output_space = 'recip', + **kwargs): + """ + PyGIX-backed Grazing Incidence Integrator + + Inputs: + inplane_config (str, default 'q_xy'): The q axis to be considered in-plane. + sample_orientation (int, default 3): the sample orientation relative to the detector. see PyGIX docs. + incident_angle (float, default 0.12): the incident angle, can also be set with .incident_angle = x.xx + tilt_angle (float, default 0): sample tilt angle, can also be set with .tilt_angle = x.xx + output_space (str, 'recip' or 'caked'): whether to produce reciprocal space (q_xy vs q_z, e.g.) data + or 'caked' style data as with PF series integrators (|q| vs chi) + + See docstring for PFGeneralIntegrator for all geometry kwargs, which work here. + + """ + self.inplane_config = inplane_config + self.sample_orientation = sample_orientation + self.incident_angle = incident_angle + self.tilt_angle = tilt_angle + self.output_space = output_space + super().__init__(**kwargs) # all other setup is done by the recreateIntegrator() function and superclass + + # def load_mask(self, da): has been superseded by PFGeneralIntegrator's methods + + # need to override this to make the PyGIX object + def recreateIntegrator(self): + ''' + recreate the integrator, after geometry change + ''' + self.integrator = pygix.Transform(dist= self.dist, + poni1 = self.poni1, + poni2 = self.poni2, + rot1 = self.rot1, + rot2 = self.rot2, + rot3 = self.rot3, + pixel1 = self.pixel1, + pixel2 = self.pixel2, + wavelength = self.wavelength, + useqx=True, + sample_orientation = self.sample_orientation, + incident_angle = self.incident_angle, + tilt_angle = self.tilt_angle) + + + def integrateSingleImage(self, da): + """ + Converts raw GIWAXS detector image to q-space data. Returns two DataArrays, Qz vs Qxy & Q vs Chi + + Inputs: Raw GIWAXS DataArray + Outputs: Cartesian & Polar DataArrays + """ + + # Initialize pygix transform object - moved to recreateIntegrator + + # the following index stack/unstack code copied from PFGeneralIntegrator + if(da.ndim>2): + img_to_integ = np.squeeze(da.values) + else: + img_to_integ = da.values + + if self.mask is None: + warnings.warn(f'No mask defined. Creating an empty mask with dimensions {img_to_integ.shape}.',stacklevel=2) + self.mask = np.zeros_like(img_to_integ) + assert np.shape(self.mask)==np.shape(img_to_integ),f'Error! Mask has shape {np.shape(self.mask)} but you are attempting to integrate data with shape {np.shape(img_to_integ)}. Try changing mask orientation or updating mask.' + stacked_axis = list(da.dims) + stacked_axis.remove('pix_x') + stacked_axis.remove('pix_y') + if len(stacked_axis)>0: + assert len(stacked_axis)==1, f"More than one dimension left after removing pix_x and pix_y, I see {stacked_axis}, not sure how to handle" + stacked_axis = stacked_axis[0] + #print(f'looking for {stacked_axis} in {img[0].indexes} (indexes), it has dims {img[0].dims} and looks like {img[0]}') + if(da.__getattr__(stacked_axis).shape[0]>1): + system_to_integ = da[0].indexes[stacked_axis] + warnings.warn(f'There are two images for {da.__getattr__(stacked_axis)}, I am ONLY INTEGRATING THE FIRST. This may cause the labels to be dropped and the result to need manual re-tagging in the index.',stacklevel=2) + else: + system_to_integ = da.indexes[stacked_axis] + + else: + stacked_axis = 'image_num' + system_to_integ = [0] + + # Cartesian 2D plot transformation + if self.output_space == 'recip': + recip_data, qxy, qz = self.integrator.transform_reciprocal(img_to_integ, + method='bbox', + unit='A', + mask=self.mask, + correctSolidAngle=self.correctSolidAngle) + + out_da = xr.DataArray(data=recip_data, + dims=['q_z', self.inplane_config], + coords={ + 'q_z': ('q_z', qz, {'units': '1/Å'}), + self.inplane_config: (self.inplane_config, qxy, {'units': '1/Å'}) + }, + attrs=da.attrs) + elif self.output_space == 'caked': + caked_data, qr, chi = self.integrator.transform_image(img_to_integ, + process='polar', + method = 'bbox', + unit='q_A^-1', + mask=self.mask, + correctSolidAngle=True) + + out_da = xr.DataArray(data=caked_data, + dims=['chi', 'qr'], + coords={ + 'chi': ('chi', chi, {'units': '°'}), + 'qr': ('qr', qr, {'units': '1/Å'}) + }, + attrs=da.attrs) + out_da.attrs['inplane_config'] = self.inplane_config + + # Preseve any existing dimension if it is in the dataarray, for stacking purposes + if stacked_axis in da.coords: + out_da = out_da.expand_dims(dim={stacked_axis: 1}).assign_coords({stacked_axis: np.array(system_to_integ)}) + # out_da = out_da.expand_dims(dim={stacked_axis: 1}) + + + return out_da + + + def __str__(self): + return f"PyGIX general integrator wrapper SDD = {self.dist} m, poni1 = {self.poni1} m, poni2 = {self.poni2} m, rot1 = {self.rot1} rad, rot2 = {self.rot2} rad" + + +# The below function is located as a method in the CMSGIWAXS class in IntegrationUtils.py +def single_images_to_dataset(files, loader, integrator): + """ + Function that takes a subscriptable object of filepaths corresponding to raw GIWAXS + beamline data, loads the raw data into an xarray DataArray, generates pygix-transformed + cartesian and polar DataArrays, and creates 3 corresponding xarray Datasets + containing a DataArray per sample. + The raw dataarrays must contain the attributes 'scan_id' and 'incident_angle' + + Inputs: files: indexable object containing pathlib.Path filepaths to raw GIWAXS data + loader: custom PyHyperScattering CMSGIWAXSLoader object, must return DataArray + integrator: instance of PGGeneralIntegrator object defined above, takes raw + dataarray and returns processed data in reciprocal space (recip or caked) + + Outputs: 2 Datasets: raw & reciprocal space (cartesian or polar based on integrator object) + """ + # Select the first element of the sorted set outside of the for loop to initialize the xr.DataSet + DA = loader.loadSingleImage(files[0]) + assert 'scan_id' in DA.attrs.keys(), "'scan_id' is a required attribute to use this function" + + # Update incident angle per sample: + assert 'incident_angle' in DA.attrs.keys(), "'incident_angle' is a required attribute to use this function" + integrator.incident_angle = float(DA.incident_angle[2:]) + + # Integrate single image + integ_DA = integrator.integrateSingleImage(DA) + + # Save coordinates for interpolating other dataarrays + integ_coords = integ_DA.coords + + # Create a DataSet, each DataArray will be named according to it's scan id + raw_DS = DA.to_dataset(name=DA.scan_id) + integ_DS = integ_DA.to_dataset(name=DA.scan_id) + + # Populate the DataSet with + for filepath in tqdm(files[1:], desc=f'Transforming Raw Data'): + DA = loader.loadSingleImage(filepath) + integ_DA = integrator.integrateSingleImage(DA) + + integ_DA = integ_DA.interp(integ_coords) + + raw_DS[f'{DA.scan_id}'] = DA + integ_DS[f'{DA.scan_id}'] = integ_DA + + return raw_DS, integ_DS + + diff --git a/src/PyHyperScattering/SST1RSoXSDB.py b/src/PyHyperScattering/SST1RSoXSDB.py index 731d77b9..64709420 100644 --- a/src/PyHyperScattering/SST1RSoXSDB.py +++ b/src/PyHyperScattering/SST1RSoXSDB.py @@ -802,17 +802,17 @@ def loadRun( else: axes_to_include = [] rsd_cutoff = 0.005 - + # begin with a list of the things that are primary streams axis_list = list(run["primary"]["data"].keys()) - + # next, knock out anything that has 'image', 'fullframe' in it - these aren't axes axis_list = [x for x in axis_list if "image" not in x] axis_list = [x for x in axis_list if "fullframe" not in x] axis_list = [x for x in axis_list if "stats" not in x] axis_list = [x for x in axis_list if "saturated" not in x] axis_list = [x for x in axis_list if "under_exposed" not in x] - + # knock out any known names of scalar counters axis_list = [x for x in axis_list if "Beamstop" not in x] axis_list = [x for x in axis_list if "Current" not in x] @@ -831,10 +831,10 @@ def loadRun( rsd = 0 else: rsd = std / motion - #print(f'Evaluating {axis} for inclusion as a dimension with rsd {rsd}...') + # print(f'Evaluating {axis} for inclusion as a dimension with rsd {rsd}...') if rsd > rsd_cutoff: axes_to_include.append(axis) - #print(f' --> it was included') + # print(f' --> it was included') # next, construct the reverse lookup table - best mapping we can make of key to pyhyper word # we start with the lookup table used by loadMd() @@ -890,7 +890,10 @@ def loadRun( data = run["primary"]["data"].read()[md["detector"] + "_image"] elif isinstance(data,tiled.client.array.DaskArrayClient): data = run["primary"]["data"].read()[md["detector"] + "_image"] - + # Handle extra dimensions (non-pixel and non-intended dimensions from repeat exposures) by averaging them along the dim_0 axis + if len(data.shape) > 3: + data = data.mean("dim_0") + data = data.astype(int) # convert from uint to handle dark subtraction if self.dark_subtract: @@ -1284,10 +1287,46 @@ def loadMd(self, run): md[phs] = None md["epoch"] = md["meas_time"].timestamp() + # looking at exposure tests in the stream and issuing warnings + if "Wide Angle CCD Detector_under_exposed" in md: + if np.any(md["Wide Angle CCD Detector_under_exposed"]): + message = "\nWide Angle CCD Detector is reported as underexposed\n" + message += "at one or more energies per definitions here:\n" + message += "https://github.com/NSLS-II-SST/rsoxs/blob/10c2c41b695c1db552f62decdde571472b71d981/rsoxs/Base/detectors.py#L110-L119\n" + if np.all(md["Wide Angle CCD Detector_under_exposed"]): + message += "Wide Angle CCD Detector is reported as underexposed at all energies." + else: + idx = np.where(md["Wide Angle CCD Detector_under_exposed"]) + warning_e = md["energy"][idx] + message += f"Affected energies include: \n{warning_e}" + warnings.warn(message, stacklevel=2) + else: + warnings.warn( + "'Wide Angle CCD Detector_under_exposed' not found in stream." + ) + if "Wide Angle CCD Detector_saturated" in md: + if np.any(md["Wide Angle CCD Detector_saturated"]): + message = "\nWide Angle CCD Detector is reported as saturated\n" + message += "at one or more energies per definitions here:\n" + message += "https://github.com/NSLS-II-SST/rsoxs/blob/10c2c41b695c1db552f62decdde571472b71d981/rsoxs/Base/detectors.py#L110-L119\n" + if np.all(md["Wide Angle CCD Detector_saturated"]): + message += "\tWide Angle CCD Detector is reported as saturated at all energies." + else: + idx = np.where(md["Wide Angle CCD Detector_saturated"]) + warning_e = md["energy"][idx] + message += f"Affected energies include: \n{warning_e}" + warnings.warn(message, stacklevel=2) + else: + warnings.warn( + "'Wide Angle CCD Detector_saturated' not found in stream." + ) + md["epoch"] = md["meas_time"].timestamp() + try: md["wavelength"] = 1.239842e-6 / md["energy"] except TypeError: md["wavelength"] = None + md["sampleid"] = start["scan_id"] md["dist"] = md["sdd"] / 1000 diff --git a/src/PyHyperScattering/_version.py b/src/PyHyperScattering/_version.py index 8a4f8b21..fb4ce8d9 100644 --- a/src/PyHyperScattering/_version.py +++ b/src/PyHyperScattering/_version.py @@ -5,8 +5,9 @@ # directories (produced by setup.py build) will contain a much shorter file # that just contains the computed version number. -# This file is released into the public domain. Generated by -# versioneer-0.20 (https://github.com/python-versioneer/python-versioneer) +# This file is released into the public domain. +# Generated by versioneer-0.29 +# https://github.com/python-versioneer/python-versioneer """Git implementation of _version.py.""" @@ -15,9 +16,11 @@ import re import subprocess import sys +from typing import Any, Callable, Dict, List, Optional, Tuple +import functools -def get_keywords(): +def get_keywords() -> Dict[str, str]: """Get the keywords needed to look up the version information.""" # these strings will be replaced by git during git-archive. # setup.py/versioneer.py will grep for the variable names, so they must @@ -30,11 +33,18 @@ def get_keywords(): return keywords -class VersioneerConfig: # pylint: disable=too-few-public-methods +class VersioneerConfig: """Container for Versioneer configuration parameters.""" + VCS: str + style: str + tag_prefix: str + parentdir_prefix: str + versionfile_source: str + verbose: bool -def get_config(): + +def get_config() -> VersioneerConfig: """Create, populate and return the VersioneerConfig() object.""" # these strings are filled in when 'setup.py versioneer' creates # _version.py @@ -52,13 +62,13 @@ class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" -LONG_VERSION_PY = {} -HANDLERS = {} +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} -def register_vcs_handler(vcs, method): # decorator +def register_vcs_handler(vcs: str, method: str) -> Callable: # decorator """Create decorator to mark a method as the handler of a VCS.""" - def decorate(f): + def decorate(f: Callable) -> Callable: """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} @@ -67,12 +77,25 @@ def decorate(f): return decorate -# pylint:disable=too-many-arguments,consider-using-with # noqa -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): +def run_command( + commands: List[str], + args: List[str], + cwd: Optional[str] = None, + verbose: bool = False, + hide_stderr: bool = False, + env: Optional[Dict[str, str]] = None, +) -> Tuple[Optional[str], Optional[int]]: """Call the given command(s).""" assert isinstance(commands, list) process = None + + popen_kwargs: Dict[str, Any] = {} + if sys.platform == "win32": + # This hides the console window if pythonw.exe is used + startupinfo = subprocess.STARTUPINFO() + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + popen_kwargs["startupinfo"] = startupinfo + for command in commands: try: dispcmd = str([command] + args) @@ -80,10 +103,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, process = subprocess.Popen([command] + args, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr - else None)) + else None), **popen_kwargs) break - except EnvironmentError: - e = sys.exc_info()[1] + except OSError as e: if e.errno == errno.ENOENT: continue if verbose: @@ -103,7 +125,11 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, return stdout, process.returncode -def versions_from_parentdir(parentdir_prefix, root, verbose): +def versions_from_parentdir( + parentdir_prefix: str, + root: str, + verbose: bool, +) -> Dict[str, Any]: """Try to determine the version from the parent directory name. Source tarballs conventionally unpack into a directory that includes both @@ -128,13 +154,13 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): @register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): +def git_get_keywords(versionfile_abs: str) -> Dict[str, str]: """Extract version information from the given file.""" # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. - keywords = {} + keywords: Dict[str, str] = {} try: with open(versionfile_abs, "r") as fobj: for line in fobj: @@ -150,13 +176,17 @@ def git_get_keywords(versionfile_abs): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["date"] = mo.group(1) - except EnvironmentError: + except OSError: pass return keywords @register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): +def git_versions_from_keywords( + keywords: Dict[str, str], + tag_prefix: str, + verbose: bool, +) -> Dict[str, Any]: """Get version information from git keywords.""" if "refnames" not in keywords: raise NotThisMethod("Short version file found") @@ -220,7 +250,12 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): @register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): +def git_pieces_from_vcs( + tag_prefix: str, + root: str, + verbose: bool, + runner: Callable = run_command +) -> Dict[str, Any]: """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* @@ -231,8 +266,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] + # GIT_DIR can interfere with correct operation of Versioneer. + # It may be intended to be passed to the Versioneer-versioned project, + # but that should not change where we get our version from. + env = os.environ.copy() + env.pop("GIT_DIR", None) + runner = functools.partial(runner, env=env) + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) + hide_stderr=not verbose) if rc != 0: if verbose: print("Directory %s not under git control" % root) @@ -240,10 +282,10 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) + describe_out, rc = runner(GITS, [ + "describe", "--tags", "--dirty", "--always", "--long", + "--match", f"{tag_prefix}[[:digit:]]*" + ], cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -253,7 +295,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() - pieces = {} + pieces: Dict[str, Any] = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None @@ -307,7 +349,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: - # unparseable. Maybe git-describe is misbehaving? + # unparsable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%s'" % describe_out) return pieces @@ -332,8 +374,8 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) - pieces["distance"] = int(count_out) # total number of commits + out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) + pieces["distance"] = len(out.split()) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() @@ -345,14 +387,14 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): return pieces -def plus_or_dot(pieces): +def plus_or_dot(pieces: Dict[str, Any]) -> str: """Return a + if we don't already have one, else return a .""" if "+" in pieces.get("closest-tag", ""): return "." return "+" -def render_pep440(pieces): +def render_pep440(pieces: Dict[str, Any]) -> str: """Build up version string, with post-release "local version identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you @@ -377,7 +419,7 @@ def render_pep440(pieces): return rendered -def render_pep440_branch(pieces): +def render_pep440_branch(pieces: Dict[str, Any]) -> str: """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . The ".dev0" means not master branch. Note that .dev0 sorts backwards @@ -407,23 +449,41 @@ def render_pep440_branch(pieces): return rendered -def render_pep440_pre(pieces): - """TAG[.post0.devDISTANCE] -- No -dirty. +def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]: + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces: Dict[str, Any]) -> str: + """TAG[.postN.devDISTANCE] -- No -dirty. Exceptions: 1: no tags. 0.post0.devDISTANCE """ if pieces["closest-tag"]: - rendered = pieces["closest-tag"] if pieces["distance"]: - rendered += ".post0.dev%d" % pieces["distance"] + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%d" % (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] else: # exception #1 rendered = "0.post0.dev%d" % pieces["distance"] return rendered -def render_pep440_post(pieces): +def render_pep440_post(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that .dev0 sorts backwards @@ -450,7 +510,7 @@ def render_pep440_post(pieces): return rendered -def render_pep440_post_branch(pieces): +def render_pep440_post_branch(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . The ".dev0" means not master branch. @@ -479,7 +539,7 @@ def render_pep440_post_branch(pieces): return rendered -def render_pep440_old(pieces): +def render_pep440_old(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. @@ -501,7 +561,7 @@ def render_pep440_old(pieces): return rendered -def render_git_describe(pieces): +def render_git_describe(pieces: Dict[str, Any]) -> str: """TAG[-DISTANCE-gHEX][-dirty]. Like 'git describe --tags --dirty --always'. @@ -521,7 +581,7 @@ def render_git_describe(pieces): return rendered -def render_git_describe_long(pieces): +def render_git_describe_long(pieces: Dict[str, Any]) -> str: """TAG-DISTANCE-gHEX[-dirty]. Like 'git describe --tags --dirty --always -long'. @@ -541,7 +601,7 @@ def render_git_describe_long(pieces): return rendered -def render(pieces, style): +def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]: """Render the given version pieces into the requested style.""" if pieces["error"]: return {"version": "unknown", @@ -577,7 +637,7 @@ def render(pieces, style): "date": pieces.get("date")} -def get_versions(): +def get_versions() -> Dict[str, Any]: """Get version information or return default if unable to do so.""" # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have # __file__, we can work backwards from there to the root. Some diff --git a/src/PyHyperScattering/integrate.py b/src/PyHyperScattering/integrate.py index 293c273b..94000a81 100644 --- a/src/PyHyperScattering/integrate.py +++ b/src/PyHyperScattering/integrate.py @@ -1,3 +1,4 @@ from PyHyperScattering.PFEnergySeriesIntegrator import PFEnergySeriesIntegrator from PyHyperScattering.PFGeneralIntegrator import PFGeneralIntegrator -from PyHyperScattering.WPIntegrator import WPIntegrator \ No newline at end of file +from PyHyperScattering.WPIntegrator import WPIntegrator +from PyHyperScattering.PGGeneralIntegrator import PGGeneralIntegrator \ No newline at end of file diff --git a/src/PyHyperScattering/load.py b/src/PyHyperScattering/load.py index 4ce1d2e3..653c88d3 100644 --- a/src/PyHyperScattering/load.py +++ b/src/PyHyperScattering/load.py @@ -3,4 +3,5 @@ from PyHyperScattering.SST1RSoXSDB import SST1RSoXSDB from PyHyperScattering.SST1RSoXSLoader import SST1RSoXSLoader from PyHyperScattering.cyrsoxsLoader import cyrsoxsLoader -from PyHyperScattering.SMIRSoXSLoader import SMIRSoXSLoader \ No newline at end of file +from PyHyperScattering.SMIRSoXSLoader import SMIRSoXSLoader +from PyHyperScattering.CMSGIWAXSLoader import CMSGIWAXSLoader diff --git a/tests/test_CMSLoader.py b/tests/test_CMSLoader.py new file mode 100644 index 00000000..c3dcbef1 --- /dev/null +++ b/tests/test_CMSLoader.py @@ -0,0 +1,35 @@ +import sys +sys.path.append("src/") + +from PyHyperScattering.load import CMSGIWAXSLoader +from PyHyperScattering.integrate import PGGeneralIntegrator + +import numpy as np +import pandas as pd +import xarray as xr +import pytest + +@pytest.fixture(autouse=True,scope='module') +def cmsloader(): + time_series_scheme = ['material', 'solvent', 'concentration', 'gap_height', + 'blade_speed','solution_temperature', + 'stage_temperature', 'sample_number', 'time_start', + 'x_position_offset', 'incident_angle', + 'exposure_time', 'scan_id','series_number', + 'detector'] + cmsloader = CMSGIWAXSLoader(md_naming_scheme = time_series_scheme) + return cmsloader + +@pytest.fixture(autouse=True,scope='module') +def CMS_giwaxs_series(cmsloader): + return cmsloader.loadFileSeries('CMS_giwaxs_series/pybtz_time_series',['series_number']) + +def test_CMS_giwaxs_series_import(CMS_giwaxs_series): + assert type(CMS_giwaxs_series)==xr.DataArray + +def test_load_insensitive_to_trailing_slash(cmsloader): + withslash = cmsloader.loadFileSeries('CMS_giwaxs_series/pybtz_time_series/',['series_number']) + + withoutslash = cmsloader.loadFileSeries('CMS_giwaxs_series/pybtz_time_series',['series_number']) + + assert np.allclose(withslash,withoutslash) \ No newline at end of file diff --git a/tests/test_PFIntegrators.py b/tests/test_PFIntegrators.py index 3c70fbac..16b005e6 100644 --- a/tests/test_PFIntegrators.py +++ b/tests/test_PFIntegrators.py @@ -44,9 +44,9 @@ def pfgenint_dask(sst_data): def test_integrator_loads_nika_mask_tiff(pfesint): - pfesint.loadNikaMask(filetoload=pathlib.Path('mask-test-pack/37738-CB_TPD314K1_mask.tif')) + pfesint.loadNikaMask(maskpath=pathlib.Path('mask-test-pack/37738-CB_TPD314K1_mask.tif')) def test_integrator_loads_nika_mask_hdf5(pfesint): - pfesint.loadNikaMask(filetoload=pathlib.Path('mask-test-pack/SST1-SAXS_mask.hdf')) + pfesint.loadNikaMask(maskpath=pathlib.Path('mask-test-pack/SST1-SAXS_mask.hdf')) def test_integrator_loads_polygon_mask(pfesint): pfesint.loadPolyMask(maskpoints=[[[367, 545], [406, 578], [880, 0], [810, 0]]],maskshape=(1024,1026)) diff --git a/tests/test_SST1DBLoader.py b/tests/test_SST1DBLoader.py index 067881b1..d8aabe95 100644 --- a/tests/test_SST1DBLoader.py +++ b/tests/test_SST1DBLoader.py @@ -10,8 +10,10 @@ SKIP_DB_TESTING=False except tiled.profiles.ProfileNotFound: try: - client = tiled.client.from_uri('https://tiled-demo.blueskyproject.io') - SKIP_DB_TESTING=True # waiting on test data to be posted to this server + import os + api_key = os.environ['TILED_API_KEY'] + client = tiled.client.from_uri('https://tiled.nsls2.bnl.gov',api_key=api_key) + SKIP_DB_TESTING=False except Exception: SKIP_DB_TESTING=True except ImportError: @@ -32,10 +34,12 @@ @pytest.fixture(autouse=True,scope='module') def sstdb(): try: - catalog = tiled.client.from_profile('rsoxs') + client = tiled.client.from_profile('rsoxs') except tiled.profiles.ProfileNotFound: - catalog = tiled.client.from_uri('https://tiled-demo.blueskyproject.io')['rsoxs']['raw'] - sstdb = SST1RSoXSDB(catalog=catalog,corr_mode='none') + import os + api_key = os.environ['TILED_API_KEY'] + client = tiled.client.from_uri('https://tiled.nsls2.bnl.gov',api_key=api_key)['rsoxs']['raw'] + sstdb = SST1RSoXSDB(catalog=client,corr_mode='none') return sstdb @must_have_tiled @@ -64,3 +68,10 @@ def test_SST1DB_load_snake_scan_explicit_dims(sstdb): assert type(run) == xr.DataArray assert 'sam_th' in run.indexes assert 'polarization' in run.indexes + +@must_have_tiled +def test_SST1DB_exposurewarnings(sstdb): + with pytest.warns(UserWarning, match="Wide Angle CCD Detector is reported as underexposed"): + sstdb.loadRun(83192) + with pytest.warns(UserWarning, match="Wide Angle CCD Detector is reported as saturated"): + sstdb.loadRun(67522) \ No newline at end of file diff --git a/tutorial/instrument-specific/CMS/cms-giwaxs_poni_generation_template.ipynb b/tutorial/instrument-specific/CMS/cms-giwaxs_poni_generation_template.ipynb new file mode 100644 index 00000000..a058308c --- /dev/null +++ b/tutorial/instrument-specific/CMS/cms-giwaxs_poni_generation_template.ipynb @@ -0,0 +1,315 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b3c13da0-ce45-4653-9fb2-5f71078d5a36", + "metadata": { + "tags": [] + }, + "source": [ + "# CMS GIWAXS mask & .poni generation notebook\n", + " \n", + "#### This notebook is incomplete and the draw.ui() is currently not working. For now, it's probably easier to just use the pyFAI or other GUIs / softwares to draw masks and generate calibration info/files. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "890da6d6-cd22-4687-a4e8-1166e36cb22d", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# # Outdated, this used to work to just overwrite existing PyHyper install in JupyterHub conda environment\n", + "# # If you need a custom PyHyper version install, you may need your own conda environment\n", + "\n", + "# # Kernel updates if needed, remember to restart kernel after running this cell!:\n", + "# !pip install -e /nsls2/users/alevin/repos/PyHyperScattering # to use pip to install via directory" + ] + }, + { + "cell_type": "markdown", + "id": "96625ca6-7ec2-4690-bf01-72b422801f76", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd667c0e-baba-4a5d-857a-ca8bd5ce1407", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports:\n", + "import pathlib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import LogNorm\n", + "import PyHyperScattering as phs\n", + "import pyFAI\n", + "from pyFAI.gui import jupyter\n", + "from pyFAI.gui.jupyter.calib import Calibration\n", + "import pygix\n", + "\n", + "print(f'Using PyHyperScattering Version: {phs.__version__}')\n", + "print(f\"Using pyFAI version {pyFAI.version}\")\n", + "\n", + "# Initialize a giwaxs data loader without any metadata naming scheme\n", + "loader = phs.load.CMSGIWAXSLoader()" + ] + }, + { + "cell_type": "markdown", + "id": "51514dec-8021-4932-b3d0-9ef35aa09a8b", + "metadata": {}, + "source": [ + "## Define paths & show calibration file" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8db0fc93-6739-457a-a7fe-ba695bb41716", + "metadata": {}, + "outputs": [], + "source": [ + "# Define paths\n", + "userPath = pathlib.Path('/nsls2/users/alevin')\n", + "propPath = pathlib.Path('/nsls2/data/cms/proposals/2023-2/pass-311415')\n", + "dataPath = propPath.joinpath('KWhite5')\n", + "calibPath = dataPath.joinpath('maxs/raw/LaB6_5.6m_12.7keV_4250.1s_x0.001_th0.120_10.00s_1118442_maxs.tiff')\n", + "maskponiPath = userPath.joinpath('giwaxs_suite/beamline_data/maskponi') # place for pyhyper-drawn masks and poni files\n", + "\n", + "# Load calibration file\n", + "LaB6_DA = loader.loadSingleImage(calibPath) # Loads the file specified at calibPath into an xr.DataArray object\n", + "energy = 13.5 # keV\n", + "\n", + "# Plot \n", + "cmap = plt.cm.viridis.copy() # Set a colormap, here I've chosen viridis\n", + "cmap.set_bad('black') # Set the color for the detector gaps\n", + "clim=(6e1, 1e3) # Specify color limits\n", + "\n", + "ax = LaB6_DA.plot.imshow(norm=LogNorm(clim[0], clim[1]), cmap=cmap, figsize=(5,4), origin='upper')\n", + "ax.axes.set(aspect='equal', title=f\"LaB6, Energy = {energy} keV\")\n", + "ax.figure.set(dpi=120)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c44a8a03-244a-4cf8-b3a3-e6cfb7121df7", + "metadata": { + "tags": [] + }, + "source": [ + "## Draw mask:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "42dd5201-6f99-4765-a7f3-0bb92530a143", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Draw mask\n", + "draw = phs.IntegrationUtils.DrawMask(LaB6_DA, clim=clim)\n", + "draw.ui()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1a32e6ec-a666-4804-b385-07fee83f8121", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Save drawn mask above\n", + "draw.save(maskponiPath.joinpath('LaB6.json'))\n", + "# draw.load(maskponiPath.joinpath('LaB6.json'))\n", + "mask = draw.mask # Loads mask as numpy array\n", + "\n", + "# Plot it over calibrant image to check\n", + "ax = LaB6_DA.plot.imshow(norm=LogNorm(clim[0], clim[1]), cmap=cmap, figsize=(5,4), origin='upper')\n", + "ax.axes.imshow(mask, alpha=0.5)\n", + "ax.axes.set(aspect='equal', title=f\"LaB6, Energy = {energy} keV\")\n", + "ax.figure.set(dpi=120)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ea514a60-05d4-4927-921a-19b68bd72ddf", + "metadata": { + "tags": [] + }, + "source": [ + "## Run pyFAI calibration:" + ] + }, + { + "cell_type": "markdown", + "id": "50090803-2eda-4991-a5b6-1966a96c4388", + "metadata": {}, + "source": [ + "### PyFAI calibration widget" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad516641-dbdf-4f6f-b281-dea4858f82b4", + "metadata": {}, + "outputs": [], + "source": [ + "# Set matplotlib backend to 'widget':\n", + "%matplotlib widget" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c49bc7b-b177-4fbe-9ab3-48badbe4fc16", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Open & run calibration widget\n", + "plt.close('all')\n", + "LaB6_da = loader.loadSingleImage(calibPath) # This is needed if you did not execute the above cells for masking\n", + "wavelength = np.round((4.1357e-15*2.99792458e8)/(energy*1000), 13) # Important to be correct! Make sure the energy is in keV and correct!\n", + "pilatus = pyFAI.detector_factory('Pilatus1M')\n", + "LaB6 = pyFAI.calibrant.CALIBRANT_FACTORY(\"LaB6\")\n", + "LaB6.wavelength = wavelength\n", + "\n", + "calib = Calibration(LaB6_da.data, calibrant=LaB6, wavelength=wavelength, detector=pilatus)" + ] + }, + { + "cell_type": "markdown", + "id": "94513d4a-0f10-4c77-9a1b-059184f5b1fe", + "metadata": {}, + "source": [ + "### Modifying & saving poni" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "20d060b7-a69e-49b5-878d-dec71496c653", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "### Check & save .poni\n", + "gr = calib.geoRef\n", + "print(gr)\n", + "print(calib.fixed)\n", + "print(gr.chi2())\n", + "# gr.save(maskponiPath.joinpath('LaB6_unfixed_rot_2023-07-15.poni'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0ee9e836-9bd4-41c6-9721-df18f44d54eb", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Optional fit with rotations fixed to 0\n", + "# Likely the best fit for transmission geometry\n", + "gr = calib.geoRef\n", + "gr.rot1=gr.rot2=gr.rot3=0\n", + "# # gr.center_array=[517, 654.47]\n", + "center_x = 517.2\n", + "# center_y = 654\n", + "gr.poni2 = center_x * gr.pixel1\n", + "# gr.poni1 = center_y * gr.pixel1\n", + "# gr.set_dist = 2.837\n", + "gr.refine3(fix=['wavelength', 'rot1', 'rot2', 'rot3', 'poni2'])\n", + "# gr.refine3(fix=['wavelength', 'rot1', 'rot2', 'rot3'])\n", + "print(gr.chi2())\n", + "print(gr)\n", + "gr.save(maskponiPath.joinpath(f'LaB6_fixed_rot_x{center_x}.poni'))" + ] + }, + { + "cell_type": "markdown", + "id": "f7b108dc-e11a-4de5-84b9-fb81c923c462", + "metadata": {}, + "source": [ + "### Calibrant check" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2b187cdc-d0f3-4d86-b115-a1b78507200c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Turn matplotlib backend back to inline mode & clear open widget plots\n", + "%matplotlib inline \n", + "plt.close('all')\n", + "\n", + "# This verifies that the calibration is good (overlays expected calibrant peaks with reduced data)\n", + "# azimuthal integrator tool in pyFAI for transmission mode (use pygix for GI geometry)\n", + "ai = pyFAI.load(str(maskponiPath.joinpath('LaB6_fixed_rot.poni'))) # Load the .poni calibration file into azimuthal integrator\n", + "res1 = ai.integrate1d(LaB6_da.data, 1000) # Circular integration\n", + "res2 = ai.integrate2d(LaB6_da.data, 1000) # Makes caked 2d image (q vs chi)\n", + "\n", + "# Plot\n", + "fig, (ax1, ax2) = plt.subplots(1, 2)\n", + "fig.set(size_inches=(10,4))\n", + "jupyter.plot1d(res1, ax=ax1, calibrant=LaB6)\n", + "jupyter.plot2d(res2, ax=ax2, calibrant=LaB6)\n", + "ax2.set_title('2D cake')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "efd1c3dc-4b87-40b1-9d18-5ff1558c6a31", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nrss", + "language": "python", + "name": "nrss" + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/instrument-specific/CMS/cms-giwaxs_readme.txt b/tutorial/instrument-specific/CMS/cms-giwaxs_readme.txt new file mode 100644 index 00000000..545338a5 --- /dev/null +++ b/tutorial/instrument-specific/CMS/cms-giwaxs_readme.txt @@ -0,0 +1,16 @@ +The general workflow to use these notebooks is as follows: + +Create a folder for your analysis and copy these notebooks into them, then: +1) cms-giwaxs_poni_generation notebook to load your calibrant file(s) and + generate poni(s) needed for data processing. This notebook is incomplete and + has not been tested recently. + +2) cms-giwaxs_...procesing... to load the raw .tiff data, convert it all to + reciprocal space (cartesian and polar coordinates), and save as datasets + -> zarr stores. + + For processing file sets of single images (no extra dimensions), it is + streamlined to use the single_images_to_dataset() method in the + PyHyperScattering.util.IntegrationUtils.CMSGIWAXS class. + +3) cms-giwaxs...plotting... to load the zarr stores and plot the loaded xarrays diff --git a/tutorial/instrument-specific/CMS/cms-giwaxs_single_image_plotting_example.ipynb b/tutorial/instrument-specific/CMS/cms-giwaxs_single_image_plotting_example.ipynb new file mode 100644 index 00000000..7f056679 --- /dev/null +++ b/tutorial/instrument-specific/CMS/cms-giwaxs_single_image_plotting_example.ipynb @@ -0,0 +1,5002 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b3c13da0-ce45-4653-9fb2-5f71078d5a36", + "metadata": {}, + "source": [ + "# CMS GIWAXS plotting notebook - plotting single images from loaded zarr datasets" + ] + }, + { + "cell_type": "markdown", + "id": "96625ca6-7ec2-4690-bf01-72b422801f76", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dd667c0e-baba-4a5d-857a-ca8bd5ce1407", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports:\n", + "import pathlib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import LogNorm\n", + "import xarray as xr\n", + "from tqdm.auto import tqdm\n", + "\n", + "# Choose a colormap:\n", + "cmap = plt.cm.turbo\n", + "cmap.set_bad('black')" + ] + }, + { + "cell_type": "markdown", + "id": "7dffa6de-0360-4fcb-b0bf-f320927837d0", + "metadata": { + "tags": [] + }, + "source": [ + "## Define & check paths" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8db0fc93-6739-457a-a7fe-ba695bb41716", + "metadata": {}, + "outputs": [], + "source": [ + "# I like pathlib for its readability & checkability, it's also necessary for the loadSeries function later on\n", + "# Replace the paths with the ones relevant to your data, you can use the \".exists()\" method to make sure you defined a path correctly\n", + "propPath = pathlib.Path('/nsls2/data/cms/proposals/2023-2/pass-311415') # The proposals path is a good place to store large data (>1 TB space?)\n", + "outPath = propPath.joinpath('AL_processed_data')\n", + "\n", + "samplesPath = outPath.joinpath('ex_situ_zarrs')" + ] + }, + { + "cell_type": "markdown", + "id": "cb87ca9c-45d4-44ed-948f-753daa6b4ab6", + "metadata": { + "tags": [] + }, + "source": [ + "## Single image GIWAXS plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e4fdac03-46b0-4814-8fed-6b0b3de72404", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['.ipynb_checkpoints',\n", + " 'caked_A1-3set-take2_waxs_stitched.zarr',\n", + " 'caked_A1-3set_waxs_stitched.zarr',\n", + " 'caked_PM6-Y6_waxs_stitched.zarr',\n", + " 'caked_PM6-Y6set_stitched.zarr',\n", + " 'caked_bladecoated_films_waxs_stitched.zarr',\n", + " 'raw_A1-3set-take2_waxs_stitched.zarr',\n", + " 'raw_A1-3set_waxs_stitched.zarr',\n", + " 'raw_PM6-Y6_waxs_stitched.zarr',\n", + " 'raw_PM6-Y6set_stitched.zarr',\n", + " 'raw_bladecoated_films_waxs_stitched.zarr',\n", + " 'recip_A1-3set-take2_waxs_stitched.zarr',\n", + " 'recip_A1-3set_waxs_stitched.zarr',\n", + " 'recip_PM6-Y6_waxs_stitched.zarr',\n", + " 'recip_PM6-Y6set_stitched.zarr',\n", + " 'recip_bladecoated_films_waxs_stitched.zarr']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# List the files inside a folder\n", + "sorted([f.name for f in samplesPath.iterdir()]) # a way to list just the filenames and not the whole path" + ] + }, + { + "cell_type": "markdown", + "id": "fbfcb7d6-878f-4fc8-a624-36ed8d3022a3", + "metadata": { + "tags": [] + }, + "source": [ + "### 2D plots" + ] + }, + { + "cell_type": "markdown", + "id": "0e4fa209-1b91-44f5-990e-8643c21f79b9", + "metadata": { + "tags": [] + }, + "source": [ + "#### Caked Images" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "96d06371-37ed-4b6b-947e-e955785b9cda", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (chi: 180, qr: 1000)\n",
+       "Coordinates:\n",
+       "  * chi      (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n",
+       "  * qr       (qr) float64 0.1393 0.1424 0.1455 0.1486 ... 3.226 3.229 3.232\n",
+       "Data variables: (12/18)\n",
+       "    1116469  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116470  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116471  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116475  (chi, qr) float32 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116476  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116477  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    ...       ...\n",
+       "    1116493  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116494  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116495  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116499  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116500  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116501  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>
" + ], + "text/plain": [ + "\n", + "Dimensions: (chi: 180, qr: 1000)\n", + "Coordinates:\n", + " * chi (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n", + " * qr (qr) float64 0.1393 0.1424 0.1455 0.1486 ... 3.226 3.229 3.232\n", + "Data variables: (12/18)\n", + " 1116469 (chi, qr) float64 dask.array\n", + " 1116470 (chi, qr) float64 dask.array\n", + " 1116471 (chi, qr) float64 dask.array\n", + " 1116475 (chi, qr) float32 dask.array\n", + " 1116476 (chi, qr) float64 dask.array\n", + " 1116477 (chi, qr) float64 dask.array\n", + " ... ...\n", + " 1116493 (chi, qr) float64 dask.array\n", + " 1116494 (chi, qr) float64 dask.array\n", + " 1116495 (chi, qr) float64 dask.array\n", + " 1116499 (chi, qr) float64 dask.array\n", + " 1116500 (chi, qr) float64 dask.array\n", + " 1116501 (chi, qr) float64 dask.array" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filename = 'caked_PM6-Y6_waxs_stitched.zarr'\n", + "DS = xr.open_zarr(samplesPath.joinpath(filename))\n", + "DS = DS.where(DS>1e-5)\n", + "DS" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "519afdb6-8f5b-4e6f-aec1-9372e1c8b6bc", + "metadata": {}, + "outputs": [], + "source": [ + "# # How one could apply a sin chi correction\n", + "# sin_chi_DA = np.sin(np.radians(np.abs(DA.chi)))\n", + "# # sin_chi_DA\n", + "\n", + "# corr_DA = DA * sin_chi_DA\n", + "# # corr_DA" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "93ef1d8d-30f2-4eb3-a72c-e437484bc2b5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# A way to select dataarrays based on attribute values:\n", + "selected_DAs = [da for da in DS.data_vars.values() if \n", + " da.attrs['incident_angle'] == 'th0.120']\n", + "display(len(selected_DAs))\n", + "\n", + "# Or use function:\n", + "def select_attrs(data_arrays_iterable, selected_attrs_dict):\n", + " \"\"\"\n", + " Selects data arrays whose attributes match the specified values.\n", + "\n", + " Parameters:\n", + " data_arrays_iterable: Iterable of xarray.DataArray objects.\n", + " selected_attrs_dict: Dictionary where keys are attribute names and \n", + " values are the attributes' desired values.\n", + "\n", + " Returns:\n", + " List of xarray.DataArray objects that match the specified attributes.\n", + " \"\"\" \n", + " sublist = list(data_arrays_iterable)\n", + " \n", + " for attr_name, attr_values in selected_attrs_dict.items():\n", + " sublist = [da.copy() for da in sublist if da.attrs[attr_name] in attr_values]\n", + " \n", + " return sublist" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f1c0569-17bb-4237-a711-72cb191351f8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Plot and optionally save selected dataarrays:\n", + "# Set chi range: Full range\n", + "chi_min = -90\n", + "chi_max = 90\n", + "\n", + "for DA in tqdm(selected_DAs):\n", + " # Slice dataarray to select plotting region \n", + " sliced_DA = DA.sel(chi=slice(chi_min,chi_max), qr=slice(0,2.1))\n", + " cmin = float(sliced_DA.compute().quantile(1e-2)) # Set color minimum value, based on quantile \n", + " cmax = float(sliced_DA.compute().quantile(1-1e-6)) # Set color maximum value, based on quantile\n", + " \n", + " # Plot sliced dataarray\n", + " ax = sliced_DA.plot.imshow(cmap=cmap, norm=LogNorm(cmin, cmax), figsize=(5,4)) # plot, optional parameter interpolation='antialiased' for image smoothing\n", + " ax.colorbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15) # set colorbar label & parameters \n", + " ax.axes.set(title=f'Polar Plot: {DA.polymer}-{DA.weight_percent}, {float(DA.incident_angle[2:])}° Incidence',\n", + " xlabel='q$_r$ [Å$^{-1}$]', ylabel='$\\chi$ [°]') # set title, axis labels, misc\n", + " ax.figure.set(tight_layout=True, dpi=130) # Adjust figure dpi & plotting style\n", + " \n", + " plt.show() # Comment to mute plotting output\n", + " \n", + " # Uncomment below line and set savepath/savename for saving plots, I usually like to check \n", + " # ax.figure.savefig(outPath.joinpath('PM6-Y6set_waxs', f'polar-2D_{DA.sample_id}_{chi_min}to{chi_max}chi_{DA.incident_angle}.png'), dpi=150)\n", + " plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b89ad7b1-406b-4c59-a9c4-70cb8b3d05b1", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Plot and optionally save selected dataarrays:\n", + "# Set chi range: In plane slice, choose a smooth section without detector gap/edge effects\n", + "chi_min = 72\n", + "chi_max = 82\n", + "\n", + "for DA in tqdm(selected_DAs):\n", + " # Slice dataarray to select plotting region \n", + " sliced_DA = DA.sel(chi=slice(chi_min,chi_max), qr=slice(0.23,2.05))\n", + " cmin = float(sliced_DA.compute().quantile(1e-2)) # Set color minimum value, based on quantile \n", + " cmax = float(sliced_DA.compute().quantile(1-1e-6)) # Set color maximum value, based on quantile\n", + " \n", + " # Plot sliced dataarray\n", + " ax = sliced_DA.plot.imshow(cmap=cmap, norm=LogNorm(cmin, cmax), figsize=(5,4)) # plot\n", + " ax.colorbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15) # set colorbar label & parameters \n", + " ax.axes.set(title=f'Polar Plot: {DA.polymer}-{DA.weight_percent}, {float(DA.incident_angle[2:])}° Incidence',\n", + " xlabel='q$_r$ [Å$^{-1}$]', ylabel='$\\chi$ [°]') # set title, axis labels, misc\n", + " ax.figure.set(tight_layout=True, dpi=130) # Adjust figure dpi & plotting style\n", + " \n", + " plt.show() # Comment to mute plotting output\n", + " \n", + " # Uncomment below line and set savepath/savename for saving plots, I usually like to check \n", + " # ax.figure.savefig(outPath.joinpath('PM6-Y6set_waxs', f'polar-2D_{DA.sample_id}_{chi_min}to{chi_max}chi_{DA.incident_angle}.png'), dpi=150)\n", + " plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "2326db38-33f2-4b64-9449-e3bdf2b30a2b", + "metadata": {}, + "outputs": [], + "source": [ + "# # A way to save data as csv files \n", + "# for DA in DS.data_vars.values():\n", + "# # qr columns, chi rows\n", + "# DA.to_pandas().to_csv(outPath.joinpath('PM6-Y6_waxs', f'polar-2D_{DA.polymer}-{DA.weight_percent}_{DA.incident_angle}_{DA.scan_id}.csv'))" + ] + }, + { + "cell_type": "markdown", + "id": "2a8a902e-8ce1-4b80-9760-975d907eb354", + "metadata": { + "tags": [] + }, + "source": [ + "#### Reciprocal Space Images" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4d456826-6758-4de8-a0ca-5765ef10b813", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (q_z: 1043, q_xy: 981)\n",
+       "Coordinates:\n",
+       "  * q_xy     (q_xy) float64 -1.219 -1.215 -1.212 -1.209 ... 2.171 2.175 2.178\n",
+       "  * q_z      (q_z) float64 0.007275 0.009704 0.01213 ... 2.534 2.537 2.539\n",
+       "Data variables: (12/18)\n",
+       "    1116469  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116470  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116471  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116475  (q_z, q_xy) float32 dask.array<chunksize=(261, 491), meta=np.ndarray>\n",
+       "    1116476  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116477  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    ...       ...\n",
+       "    1116493  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116494  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116495  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116499  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116500  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>\n",
+       "    1116501  (q_z, q_xy) float64 dask.array<chunksize=(261, 246), meta=np.ndarray>
" + ], + "text/plain": [ + "\n", + "Dimensions: (q_z: 1043, q_xy: 981)\n", + "Coordinates:\n", + " * q_xy (q_xy) float64 -1.219 -1.215 -1.212 -1.209 ... 2.171 2.175 2.178\n", + " * q_z (q_z) float64 0.007275 0.009704 0.01213 ... 2.534 2.537 2.539\n", + "Data variables: (12/18)\n", + " 1116469 (q_z, q_xy) float64 dask.array\n", + " 1116470 (q_z, q_xy) float64 dask.array\n", + " 1116471 (q_z, q_xy) float64 dask.array\n", + " 1116475 (q_z, q_xy) float32 dask.array\n", + " 1116476 (q_z, q_xy) float64 dask.array\n", + " 1116477 (q_z, q_xy) float64 dask.array\n", + " ... ...\n", + " 1116493 (q_z, q_xy) float64 dask.array\n", + " 1116494 (q_z, q_xy) float64 dask.array\n", + " 1116495 (q_z, q_xy) float64 dask.array\n", + " 1116499 (q_z, q_xy) float64 dask.array\n", + " 1116500 (q_z, q_xy) float64 dask.array\n", + " 1116501 (q_z, q_xy) float64 dask.array" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filename = 'recip_PM6-Y6_waxs_stitched.zarr'\n", + "DS = xr.open_zarr(samplesPath.joinpath(filename))\n", + "DS = DS.where(DS>1e-5)\n", + "DS" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0b992c21-2ee9-466c-90d8-737a000efdfa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selected_DAs = [da for da in DS.data_vars.values() if \n", + " da.attrs['incident_angle'] == 'th0.120']\n", + "len(selected_DAs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de525325-773d-4ce5-908c-aa6facf88dc7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Plot & optionally save each selected polymer:-{DA.weight_percent}\n", + "for DA in tqdm(selected_DAs):\n", + " # Slice data for selected q ranges (will need to rename q_xy if dimensions are differently named)\n", + " sliced_DA = DA.sel(q_xy=slice(-1.1, 2.1), q_z=slice(0, 2.2))\n", + " cmin = float(sliced_DA.compute().quantile(1e-2))\n", + " cmax = float(sliced_DA.compute().quantile(1-1e-8)) \n", + " \n", + " # Same plotting procedure as above\n", + " ax = sliced_DA.plot.imshow(cmap=cmap, norm=LogNorm(cmin, cmax), interpolation='antialiased', figsize=(5.5,3.3))\n", + " ax.colorbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15)\n", + " ax.axes.set(aspect='equal', title=f'Cartesian Plot: {DA.polymer}-{DA.weight_percent}, {float(DA.incident_angle[2:])}° Incidence',\n", + " xlabel='q$_{xy}$ [Å$^{-1}$]', ylabel='q$_z$ [Å$^{-1}$]')\n", + " ax.figure.set(tight_layout=True, dpi=130)\n", + " \n", + " # ax.figure.savefig(outPath.joinpath('PM6-Y6set_waxs', f'cartesian-2D_{DA.polymer}-{DA.weight_percent}_{DA.incident_angle}.png'), dpi=150)\n", + " plt.show()\n", + " plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "12a0b2cb-f757-446d-85e4-8a130b147e44", + "metadata": {}, + "outputs": [], + "source": [ + "# # A way to save data as csv files\n", + "# for DA in tqdm(DS.data_vars.values()):\n", + "# # qxy columns, qz rows\n", + "# DA.to_pandas().to_csv(outPath.joinpath('PM6-Y6_waxs', f'cartesian-2D_{DA.polymer}-{DA.weight_percent}_{DA.incident_angle}_{DA.scan_id}.csv'))" + ] + }, + { + "cell_type": "markdown", + "id": "f164c8c0-98bb-43b3-8d63-9d6de075640e", + "metadata": { + "tags": [] + }, + "source": [ + "### 1D Plots" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "38841f0e-dcb4-4c6b-abb4-cd70d77f7e8f", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (chi: 180, qr: 1000)\n",
+       "Coordinates:\n",
+       "  * chi      (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n",
+       "  * qr       (qr) float64 0.1393 0.1424 0.1455 0.1486 ... 3.226 3.229 3.232\n",
+       "Data variables: (12/18)\n",
+       "    1116469  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116470  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116471  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116475  (chi, qr) float32 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116476  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116477  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    ...       ...\n",
+       "    1116493  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116494  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116495  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116499  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116500  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>\n",
+       "    1116501  (chi, qr) float64 dask.array<chunksize=(90, 500), meta=np.ndarray>
" + ], + "text/plain": [ + "\n", + "Dimensions: (chi: 180, qr: 1000)\n", + "Coordinates:\n", + " * chi (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n", + " * qr (qr) float64 0.1393 0.1424 0.1455 0.1486 ... 3.226 3.229 3.232\n", + "Data variables: (12/18)\n", + " 1116469 (chi, qr) float64 dask.array\n", + " 1116470 (chi, qr) float64 dask.array\n", + " 1116471 (chi, qr) float64 dask.array\n", + " 1116475 (chi, qr) float32 dask.array\n", + " 1116476 (chi, qr) float64 dask.array\n", + " 1116477 (chi, qr) float64 dask.array\n", + " ... ...\n", + " 1116493 (chi, qr) float64 dask.array\n", + " 1116494 (chi, qr) float64 dask.array\n", + " 1116495 (chi, qr) float64 dask.array\n", + " 1116499 (chi, qr) float64 dask.array\n", + " 1116500 (chi, qr) float64 dask.array\n", + " 1116501 (chi, qr) float64 dask.array" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filename = 'caked_PM6-Y6_waxs_stitched.zarr'\n", + "DS = xr.open_zarr(samplesPath.joinpath(filename))\n", + "DS = DS.where(DS>1e-5)\n", + "DS" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "f3a4cd9d-e268-4e87-897e-9102f1980336", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "selected_DAs = [da for da in DS.data_vars.values() if \n", + " da.attrs['incident_angle'] == 'th0.120']\n", + "len(selected_DAs)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3d3f6381-4597-41f5-916d-cd805f1ba00b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Plot linecuts for selected chi ranges, here I've put both in plane and out of plane selections into the loop\n", + "\n", + "for DA in tqdm(selected_DAs):\n", + " # OOP\n", + " chi_min = -18\n", + " chi_max = -8\n", + " DA.sel(chi=slice(chi_min, chi_max), qr=slice(0.14,2.01)).sum('chi').plot.line(figsize=(6,4))\n", + "\n", + " # A plot.line xarray plot does not return an AxesImage object like imshow does, so I use plt.gca() and plt.gcf() to access the axes & figure parameters\n", + " ax = plt.gca()\n", + " fig = plt.gcf()\n", + " \n", + " ax.set(title=f'OOP Linecut, {chi_min}° to {chi_max}° $\\chi$: {DA.polymer}-{DA.weight_percent}, {float(DA.incident_angle[2:])}° Incidence',\n", + " yscale='log', ylabel='Intensity [arb. units]', xlabel='q$_r$ [Å$^{-1}$]')\n", + " ax.grid(visible=True, which='major', axis='x')\n", + " fig.set(tight_layout=True, dpi=130)\n", + " \n", + " plt.show()\n", + " # fig.savefig(outPath.joinpath('PM6-Y6set_waxs', f'linecut_OOP_{DA.polymer}-{DA.weight_percent}_{chi_min}to{chi_max}chi_{DA.incident_angle}.png'), dpi=150)\n", + " plt.close('all')\n", + " \n", + " # IP\n", + " chi_min = 72\n", + " chi_max = 82\n", + " DA.sel(chi=slice(chi_min, chi_max), qr=slice(0.23,2.01)).sum('chi').plot.line(figsize=(6,4)) \n", + " \n", + " ax = plt.gca()\n", + " fig = plt.gcf()\n", + " \n", + " ax.set(title=f'IP Linecut, {chi_min}° to {chi_max}° $\\chi$: {DA.polymer}-{DA.weight_percent}, {float(DA.incident_angle[2:])}° Incidence',\n", + " yscale='log', ylabel='Intensity [arb. units]', xlabel='q$_r$ [Å$^{-1}$]')\n", + " ax.grid(visible=True, which='major', axis='x')\n", + " fig.set(tight_layout=True, dpi=130)\n", + " \n", + " plt.show()\n", + " # fig.savefig(outPath.joinpath('PM6-Y6set_waxs', f'linecut_IP_{DA.polymer}-{DA.weight_percent}_{chi_min}to{chi_max}chi_{DA.incident_angle}.png'), dpi=150)\n", + " plt.close('all')\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d21e65b-229b-4cba-9cd1-c80ab7a271e2", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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/tutorial/instrument-specific/CMS/cms-giwaxs_single_image_processing_example.ipynb b/tutorial/instrument-specific/CMS/cms-giwaxs_single_image_processing_example.ipynb new file mode 100644 index 00000000..7734aa52 --- /dev/null +++ b/tutorial/instrument-specific/CMS/cms-giwaxs_single_image_processing_example.ipynb @@ -0,0 +1,2427 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b3c13da0-ce45-4653-9fb2-5f71078d5a36", + "metadata": {}, + "source": [ + "# CMS ex situ GIWAXS 2023C2\n", + "\n", + "# CMS GIWAXS raw data processing & exporting notebook\n", + "In this notebook you output xr.DataSets stored as .zarr stores containing all your raw,\n", + "remeshed (reciprocal space), and caked CMS GIWAXS data. Saving as a zarr automatically converts the array to a dask array" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "890da6d6-cd22-4687-a4e8-1166e36cb22d", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# # Outdated, this used to work to just overwrite existing PyHyper install in JupyterHub conda environment\n", + "# # If you need a custom PyHyper version install, you may need your own conda environment\n", + "\n", + "# # Kernel updates if needed, remember to restart kernel after running this cell!:\n", + "# !pip install -e /nsls2/users/alevin/repos/PyHyperScattering # to use pip to install via directory" + ] + }, + { + "cell_type": "markdown", + "id": "96625ca6-7ec2-4690-bf01-72b422801f76", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd667c0e-baba-4a5d-857a-ca8bd5ce1407", + "metadata": {}, + "outputs": [], + "source": [ + "### Imports:\n", + "import pathlib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import LogNorm\n", + "import xarray as xr\n", + "import PyHyperScattering as phs\n", + "import pygix\n", + "import gc\n", + "from tqdm.auto import tqdm # progress bar loader!\n", + "\n", + "print(f'Using PyHyperScattering Version: {phs.__version__}')" + ] + }, + { + "cell_type": "markdown", + "id": "7dffa6de-0360-4fcb-b0bf-f320927837d0", + "metadata": { + "tags": [] + }, + "source": [ + "## Defining some objects" + ] + }, + { + "cell_type": "markdown", + "id": "b36b6f6c-4643-46b3-9784-9a6071c754ba", + "metadata": {}, + "source": [ + "### Define & check paths" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c8f350e9-c48f-4722-b90b-abfd1d6468d7", + "metadata": {}, + "outputs": [], + "source": [ + "# I like pathlib for its readability & checkability, it's also necessary for the loadSeries function later on\n", + "# Replace the paths with the ones relevant to your data, you can use the \".exists()\" method to make sure you defined a path correctly\n", + "userPath = pathlib.Path('/nsls2/users/alevin')\n", + "propPath = pathlib.Path('/nsls2/data/cms/proposals/2023-3/pass-311415')\n", + "dataPath = propPath.joinpath('AL_processed_data/KWhite2/waxs')\n", + "rawPath = dataPath.joinpath('raw')\n", + "samplesPath = dataPath.joinpath('stitched')\n", + "calibPath = rawPath.joinpath('AgBH_cali_5m_12.7kev_x0.000_th0.000_10.00s_1307208_waxs.tiff')\n", + "maskponiPath = propPath.joinpath('AL_processed_data/maskponi') # place for pyhyper-drawn masks and poni files\n", + "\n", + "outPath = propPath.joinpath('AL_processed_data')\n", + "\n", + "# Select poni & mask filepaths\n", + "poniFile = maskponiPath.joinpath('CeO2_2023-12-03_y673_x464p3.poni')\n", + "# maskFile = maskponiPath.joinpath('blank.json')\n", + "maskFile = maskponiPath.joinpath('pilatus1m_vertical_gaps_only.json')\n", + "\n", + "# Colormap\n", + "cmap = plt.cm.turbo\n", + "cmap.set_bad('black')" + ] + }, + { + "cell_type": "markdown", + "id": "c1840638-1577-4dea-8819-ffb69d6f80b8", + "metadata": {}, + "source": [ + "### Define metadata naming scheme & initialize loaders" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2616140d-0dca-4212-a25c-3fb2258decf0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "[f.name for f in sorted(samplesPath.glob('*pos1*'))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f169ce3f-060a-4e16-b434-a99f02740a60", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "[len(f.name.split('_')) for f in sorted(samplesPath.glob('*pos1*'))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23eb25a1-8b83-4106-81fb-39882a0ef8f3", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "[f.name for f in sorted(samplesPath.glob('*pos1*')) if len(f.name.split('_'))==9]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ae9b6357-6dae-44e1-92d4-b9b0c0822726", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "fixed_rpm_set = [f for f in sorted(samplesPath.glob('*')) if len(f.name.split('_'))==9]\n", + "variable_rpm_set = [f for f in sorted(samplesPath.glob('*')) if len(f.name.split('_'))==10]" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b1d7fd17-31e5-49cd-851b-b44dd9e94223", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "112" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(fixed_rpm_set)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5d4b36ad-7f88-4410-b023-a9b01d918117", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "64" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(variable_rpm_set)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "321cb55f-ffa4-4a6b-b511-56d6a164dc0e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Filename: AL_PM6-Y6BO_CBCN_pos1_x-0.000_th0.080_10.00s_1306661_wax.tiff\n", + "('project', 'AL')\n", + "('material', 'PM6-Y6BO')\n", + "('solvent', 'CBCN')\n", + "('detector_pos', 'pos1')\n", + "('sample_pos', 'x-0.000')\n", + "('incident_angle', 'th0.080')\n", + "('exposure_time', '10.00s')\n", + "('scan_id', '1306661')\n", + "('detector', 'wax.tiff')\n", + "\n", + "Filename: AL_Y6BO_CB_2000_pos1_x-0.000_th0.080_10.00s_1306221_wax.tiff\n", + "('project', 'AL')\n", + "('material', 'Y6BO')\n", + "('solvent', 'CB')\n", + "('rpm', '2000')\n", + "('detector_pos', 'pos1')\n", + "('sample_pos', 'x-0.000')\n", + "('incident_angle', 'th0.080')\n", + "('exposure_time', '10.00s')\n", + "('scan_id', '1306221')\n", + "('detector', 'wax.tiff')\n" + ] + } + ], + "source": [ + "# set ex situ metadata filename naming schemes:\n", + "fixed_rpm_md_naming_scheme = ['project', 'material', 'solvent', 'detector_pos', 'sample_pos', \n", + " 'incident_angle', 'exposure_time', 'scan_id', 'detector']\n", + "variable_rpm_md_naming_scheme = ['project', 'material', 'solvent', 'rpm', 'detector_pos', 'sample_pos', \n", + " 'incident_angle', 'exposure_time', 'scan_id', 'detector']\n", + "\n", + "# A way to check our naming schemes to make sure they're right:\n", + "delim = '_'\n", + "file_sets = [ fixed_rpm_set, variable_rpm_set]\n", + "file_schemes = [fixed_rpm_md_naming_scheme, variable_rpm_md_naming_scheme]\n", + "\n", + "for file_set, file_scheme in zip(file_sets, file_schemes):\n", + " first_filename = sorted(file_set)[0].name\n", + " print(f'\\nFilename: {first_filename}')\n", + " first_filename_list = first_filename.split(delim)\n", + " for tup in zip(file_scheme, first_filename_list):\n", + " print(tup)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a486d1f7-236f-4e16-8342-0bf1f4a2cce9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Initalize CMSGIWAXSLoader objects with the above naming schemes\n", + "fixed_rpm_loader = phs.load.CMSGIWAXSLoader(md_naming_scheme=fixed_rpm_md_naming_scheme)\n", + "variable_rpm_loader = phs.load.CMSGIWAXSLoader(md_naming_scheme=variable_rpm_md_naming_scheme)" + ] + }, + { + "cell_type": "markdown", + "id": "89d72a19-8729-4ebd-914a-9cba20016a72", + "metadata": { + "tags": [] + }, + "source": [ + "## Data processing\n", + "Break this section up however makes sense for your data" + ] + }, + { + "cell_type": "markdown", + "id": "3c42033d-6f6b-460f-8b3d-b888b9b61df3", + "metadata": { + "tags": [] + }, + "source": [ + "### Variable RPM file set" + ] + }, + { + "cell_type": "markdown", + "id": "aca683fa-c51d-4dde-9af5-bb3ff16f73df", + "metadata": { + "tags": [] + }, + "source": [ + "#### intialize integrators" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "9371713d-e110-48f6-ada6-a1ee78bf3747", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "variable_rpm_recip_integrator = phs.integrate.PGGeneralIntegrator(geomethod = 'ponifile',\n", + " ponifile = poniFile,\n", + " output_space = 'recip')\n", + "variable_rpm_caked_integrator = phs.integrate.PGGeneralIntegrator(geomethod = 'ponifile',\n", + " ponifile = poniFile,\n", + " output_space = 'caked')" + ] + }, + { + "cell_type": "markdown", + "id": "9d168daa-2be6-49c7-abff-a919f8e51794", + "metadata": { + "tags": [] + }, + "source": [ + "#### generate, check, save: recip Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "40a9b955-c829-4235-a000-3f604fc9a174", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/nsls2/users/alevin/repos/PyHyperScattering/src/PyHyperScattering/IntegrationUtils.py:242: UserWarning: No mask defined. Creating an empty mask with dimensions (1073, 981).\n", + " integ_DA = self.integrator.integrateSingleImage(DA)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "77b92333fb764722a6f27811ebe07b53", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Transforming Raw Data: 0%| | 0/63 [00:00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (q_z: 1073, q_xy: 981)\n",
+       "Coordinates:\n",
+       "  * q_z      (q_z) float64 -1.647 -1.643 -1.639 -1.635 ... 2.613 2.617 2.621\n",
+       "  * q_xy     (q_xy) float64 -1.912 -1.908 -1.904 -1.9 ... 2.1 2.104 2.108 2.112\n",
+       "Data variables: (12/64)\n",
+       "    1306221  (q_z, q_xy) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306222  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306223  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306224  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306229  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306230  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    ...       ...\n",
+       "    1306357  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306358  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306363  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306364  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306365  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306366  (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
" + ], + "text/plain": [ + "\n", + "Dimensions: (q_z: 1073, q_xy: 981)\n", + "Coordinates:\n", + " * q_z (q_z) float64 -1.647 -1.643 -1.639 -1.635 ... 2.613 2.617 2.621\n", + " * q_xy (q_xy) float64 -1.912 -1.908 -1.904 -1.9 ... 2.1 2.104 2.108 2.112\n", + "Data variables: (12/64)\n", + " 1306221 (q_z, q_xy) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306222 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306223 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306224 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306229 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306230 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " ... ...\n", + " 1306357 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306358 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306363 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306364 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306365 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306366 (q_z, q_xy) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use the single_images_to_dataset utility function to pygix transform all raw files in an indexable list\n", + "# Located in the IntegrationUtils script, CMSGIWAXS class:\n", + "\n", + "# Initalize CMSGIWAXS util object\n", + "util = phs.util.IntegrationUtils.CMSGIWAXS(sorted(variable_rpm_set), variable_rpm_loader, variable_rpm_recip_integrator)\n", + "raw_DS, recip_DS = util.single_images_to_dataset() # run function \n", + "display(recip_DS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d7772d3a-fab7-44a5-b39d-96256ce1f934", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Example of a quick plot check if desired here:\n", + "# for DA in tqdm(list(recip_DS.data_vars.values())[::8]): \n", + "# cmin = DA.quantile(0.01)\n", + "# cmax = DA.quantile(0.99)\n", + " \n", + "# ax = DA.sel(q_xy=slice(-1.1, 2.1), q_z=slice(-0.05, 2.4)).plot.imshow(cmap=cmap, norm=plt.Normalize(cmin, cmax), figsize=(8,4))\n", + "# ax.axes.set(aspect='equal', title=f'{DA.material}, incident angle: {DA.incident_angle}, scan id: {DA.scan_id}')\n", + "# plt.show()\n", + "# plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5419c7e6-919c-4d3c-972f-6b35fe69fac4", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Saving dataset with xarray's to_zarr() method:\n", + "# # General structure below:\n", + "\n", + "# # Set where to save file and what to name it\n", + "# savePath = outPath.joinpath('testing_zarrs')\n", + "# savePath.mkdir(exist_ok=True)\n", + "# savename = 'custom_save_name.zarr'\n", + "\n", + "# # Save it\n", + "# recip_DS.to_zarr(savePath.joinpath(savename))" + ] + }, + { + "cell_type": "markdown", + "id": "36ff2faa-7c5f-4674-ab07-50a08d77d37d", + "metadata": { + "tags": [] + }, + "source": [ + "#### generate, check, save: caked Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e22bf04b-a288-484d-be79-c27156b57999", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/nsls2/users/alevin/repos/PyHyperScattering/src/PyHyperScattering/IntegrationUtils.py:242: UserWarning: No mask defined. Creating an empty mask with dimensions (1073, 981).\n", + " integ_DA = self.integrator.integrateSingleImage(DA)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5b5c99e0de5f4e3b9f6220f7dbdb9fbf", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Transforming Raw Data: 0%| | 0/63 [00:00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (chi: 180, qr: 1000)\n",
+       "Coordinates:\n",
+       "  * chi      (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n",
+       "  * qr       (qr) float64 0.0009973 0.004259 0.007521 ... 3.253 3.256 3.26\n",
+       "Data variables: (12/64)\n",
+       "    1306221  (chi, qr) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306222  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306223  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306224  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306229  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306230  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    ...       ...\n",
+       "    1306357  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306358  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306363  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306364  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306365  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1306366  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
" + ], + "text/plain": [ + "\n", + "Dimensions: (chi: 180, qr: 1000)\n", + "Coordinates:\n", + " * chi (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n", + " * qr (qr) float64 0.0009973 0.004259 0.007521 ... 3.253 3.256 3.26\n", + "Data variables: (12/64)\n", + " 1306221 (chi, qr) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306222 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306223 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306224 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306229 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306230 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " ... ...\n", + " 1306357 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306358 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306363 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306364 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306365 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1306366 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use the single_images_to_dataset utility function to pygix transform all raw files in an indexable list\n", + "# Located in the IntegrationUtils script, CMSGIWAXS class:\n", + "\n", + "# Initalize CMSGIWAXS util object\n", + "util = phs.util.IntegrationUtils.CMSGIWAXS(sorted(variable_rpm_set), variable_rpm_loader, variable_rpm_caked_integrator)\n", + "raw_DS, caked_DS = util.single_images_to_dataset() # run function \n", + "display(caked_DS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6eea399d-80ce-4c16-96f5-9d271868a612", + "metadata": {}, + "outputs": [], + "source": [ + "# Example of a quick plot check if desired here:\n", + "for DA in tqdm(list(caked_DS.data_vars.values())[::8]): \n", + " cmin = DA.quantile(0.01)\n", + " cmax = DA.quantile(0.99)\n", + " \n", + " ax = DA.plot.imshow(cmap=cmap, norm=plt.Normalize(cmin, cmax), figsize=(8,4))\n", + " ax.axes.set(title=f'{DA.material}, incident angle: {DA.incident_angle}, scan id: {DA.scan_id}')\n", + " plt.show()\n", + " plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51ab45b4-b88a-480c-9f82-ef2821c45482", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Saving dataset with xarray's to_zarr() method:\n", + "# # General structure below:\n", + "\n", + "# # Set where to save file and what to name it\n", + "# savePath = outPath.joinpath('testing_zarrs')\n", + "# savePath.mkdir(exist_ok=True)\n", + "# savename = 'custom_save_name.zarr'\n", + "\n", + "# # Save it\n", + "# caked_DS.to_zarr(savePath.joinpath(savename))" + ] + }, + { + "cell_type": "markdown", + "id": "f1e89c23-74e6-4857-8668-e037b0f66c97", + "metadata": {}, + "source": [ + "### Fixed RPM file set" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e956d4de-1284-4d5f-b874-49bd3afa52e6", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# would be same code as above for another file set" + ] + }, + { + "cell_type": "markdown", + "id": "ad98a0c7-37c9-42c1-84c3-caca50c454d6", + "metadata": {}, + "source": [ + "## Not fully implemented" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "08506682-c5ee-4e83-9a52-c73af7e71e6b", + "metadata": {}, + "outputs": [], + "source": [ + "def poni_centers(poniFile, pix_size=0.000172):\n", + " \"\"\"\n", + " Returns poni center value and the corresponding pixel position. Default pixel size is 172 microns (Pilatus 1M)\n", + " \n", + " Inputs: poniFile as pathlib path object to the poni file\n", + " Outputs: ((poni1, y_center), (poni2, x_center))\n", + " \"\"\"\n", + " \n", + " with poniFile.open('r') as f:\n", + " lines = list(f.readlines())\n", + " poni1_str = lines[6]\n", + " poni2_str = lines[7]\n", + "\n", + " poni1 = float(poni1_str.split(' ')[1])\n", + " poni2 = float(poni2_str.split(' ')[1])\n", + "\n", + " y_center = poni1 / pix_size\n", + " x_center = poni2 / pix_size\n", + " \n", + " return ((poni1, y_center), (poni2, x_center))\n", + "\n", + "poni_y, poni_x = poni_centers(poniFile)\n", + "display(poni_y)\n", + "display(poni_x)" + ] + }, + { + "cell_type": "markdown", + "id": "8bb850be-2166-49ca-893d-6ff46e34afad", + "metadata": { + "tags": [] + }, + "source": [ + "### Yoneda check:\n", + "This can be used as a way to verify / refine your correct beam center y position. The yoneda peak should always appear at a q value corresponding to your incident angle plus your film's critical angle:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3233995c-839f-4b02-b3f9-65bc00d41e63", + "metadata": {}, + "outputs": [], + "source": [ + "def yoneda_qz(wavelength, alpha_crit, alpha_incidents):\n", + " \"\"\"Calculate the yoneda qz values given the wavelength, critical angle, and incident angle (in degrees)\"\"\"\n", + " qz_inv_meters = ((4 * np.pi) / (wavelength)) * (np.sin(np.deg2rad((alpha_incidents + alpha_crit)/2)))\n", + " qz_inv_angstroms = qz_inv_meters / 1e10\n", + " return qz_inv_angstroms\n", + "\n", + "\n", + "wavelength = 9.762535309700809e-11 # 12.7 keV\n", + "alpha_crit = 0.11 # organic film critical angle\n", + "alpha_incidents = np.array([0.08, 0.1, 0.12, 0.15]) # incident angle(s)\n", + "\n", + "yoneda_angles = alpha_incidents + alpha_crit\n", + "\n", + "yoneda_qz(wavelength, alpha_crit, alpha_incidents) # expected yoneda qz positions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84692bd3-0b35-4f69-98db-416592d03dda", + "metadata": {}, + "outputs": [], + "source": [ + "def select_attrs(data_arrays_iterable, selected_attrs_dict):\n", + " \"\"\"\n", + " Selects data arrays whose attributes match the specified values.\n", + "\n", + " Parameters:\n", + " data_arrays_iterable: Iterable of xarray.DataArray objects.\n", + " selected_attrs_dict: Dictionary where keys are attribute names and \n", + " values are the attributes' desired values.\n", + "\n", + " Returns:\n", + " List of xarray.DataArray objects that match the specified attributes.\n", + " \"\"\" \n", + " sublist = list(data_arrays_iterable)\n", + " \n", + " for attr_name, attr_values in selected_attrs_dict.items():\n", + " sublist = [da for da in sublist if da.attrs[attr_name] in attr_values]\n", + " \n", + " return sublist" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c0bcd25-8b2f-439f-a2bd-af0021a3a102", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# 2D reciprocal space cartesian plots\n", + "qxy_min = -1.1\n", + "qxy_max = 2.1\n", + "qz_min = -0.01\n", + "qz_max = 2.2\n", + "\n", + "selected_attrs_dict = {'material': ['PM6'], 'solvent': ['CBCN']}\n", + "# selected_attrs_dict = {}\n", + "\n", + "selected_DAs = select_attrs(fixed_recip_DS.data_vars.values(), selected_attrs_dict)\n", + "for DA in tqdm(selected_DAs):\n", + " # Slice data for selected q ranges (will need to rename q_xy if dimensions are differently named)\n", + " sliced_DA = DA.sel(q_xy=slice(qxy_min, qxy_max), q_z=slice(qz_min, qz_max))\n", + " \n", + " real_min = float(sliced_DA.compute().quantile(0.05))\n", + " cmin = 1 if real_min < 1 else real_min\n", + "\n", + " cmax = float(sliced_DA.compute().quantile(0.997)) \n", + " \n", + " # Plot\n", + " ax = sliced_DA.plot.imshow(cmap=cmap, norm=plt.Normalize(cmin, cmax), interpolation='antialiased', figsize=(5.5,3.3))\n", + " ax.colorbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15)\n", + " # ax.axes.set(aspect='equal', title=f'Cartesian Plot: {DA.material} {DA.solvent} {DA.rpm}, {float(DA.incident_angle[2:])}° Incidence',\n", + " # xlabel='q$_{xy}$ [Å$^{-1}$]', ylabel='q$_z$ [Å$^{-1}$]')\n", + " ax.axes.set(aspect='equal', title=f'Cartesian Plot: {DA.material} {DA.solvent}, {float(DA.incident_angle[2:])}° Incidence',\n", + " xlabel='q$_{xy}$ [Å$^{-1}$]', ylabel='q$_z$ [Å$^{-1}$]')\n", + " ax.figure.set(tight_layout=True, dpi=130)\n", + " \n", + " # ax.figure.savefig(savePath.joinpath(f'{DA.material}-{DA.solvent}-{DA.rpm}_qxy{qxy_min}to{qxy_max}_qz{qz_min}to{qz_max}_{DA.incident_angle}.png'), dpi=150)\n", + " # ax.figure.savefig(savePath.joinpath(f'{DA.material}-{DA.solvent}_qxy{qxy_min}to{qxy_max}_qz{qz_min}to{qz_max}_{DA.incident_angle}.png'), dpi=150)\n", + "\n", + " plt.show()\n", + " plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a956c001-a512-42bb-b390-0375bf84c2fb", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Yoneda peak linecut check\n", + "qxy_min = 0.22\n", + "qxy_max = 2\n", + "qz_min = -0.02\n", + "qz_max = 0.06\n", + "\n", + "selected_DAs = select_attrs(fixed_recip_DS.data_vars.values(), selected_attrs_dict)\n", + "for DA in tqdm(selected_DAs):\n", + " # Slice data for selected q ranges (will need to rename q_xy if dimensions are differently named)\n", + " sliced_DA = DA.sel(q_xy=slice(qxy_min, qxy_max), q_z=slice(qz_min, qz_max))\n", + " qz_integrated_DA = sliced_DA.sum('q_xy')\n", + " \n", + " # Plot\n", + " qz_integrated_DA.plot.line(label=DA.incident_angle)\n", + " \n", + "plt.legend()\n", + "plt.grid(visible=True, which='major', axis='x')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5315e1d2-82c5-4c47-adf7-7b8c2f294b64", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "chi_min = 60\n", + "chi_max = None\n", + "\n", + "selected_DAs = select_attrs(fixed_caked_DS.data_vars.values(), selected_attrs_dict)\n", + "for DA in tqdm(selected_DAs):\n", + " # Slice dataarray to select plotting region \n", + " sliced_DA = DA.sel(chi=slice(chi_min,chi_max))\n", + " \n", + " # real_min = float(DA.sel(q_xy=slice(-0.5, -0.1), q_z=slice(0.1, 0.4)).compute().quantile(1e-3))\n", + " real_min = float(DA.compute().quantile(0.05))\n", + " cmin = 1 if real_min < 1 else real_min\n", + " \n", + " # cmax = float(DA.sel(q_xy=slice(-0.5, -0.1), q_z=slice(0.1, 2)).compute().quantile(1)) \n", + " cmax = float(DA.compute().quantile(0.999)) \n", + " \n", + " # Plot sliced dataarray\n", + " ax = sliced_DA.plot.imshow(cmap=cmap, norm=plt.Normalize(cmin, 10), figsize=(5,4), interpolation='antialiased') # plot, optional parameter interpolation='antialiased' for image smoothing\n", + " ax.colorbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15) # set colorbar label & parameters \n", + " ax.axes.set(title=f'Polar Plot: {DA.material} {DA.solvent}, {float(DA.incident_angle[2:])}° Incidence',\n", + " xlabel='q$_r$ [Å$^{-1}$]', ylabel='$\\chi$ [°]') # set title, axis labels, misc\n", + " ax.figure.set(tight_layout=True, dpi=130) # Adjust figure dpi & plotting style\n", + " \n", + " plt.show() # Comment to mute plotting output\n", + " \n", + " # Uncomment below line and set savepath/savename for saving plots, I usually like to check \n", + " # ax.figure.savefig(outPath.joinpath('PM6-Y6set_waxs', f'polar-2D_{DA.sample_id}_{chi_min}to{chi_max}chi_{DA.incident_angle}.png'), dpi=150)\n", + " plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7d4a0f5c-31cb-4cba-be2e-4cad27d273df", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nrss", + "language": "python", + "name": "nrss" + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/instrument-specific/CMS/cms-giwaxs_time_series_plotting_example.ipynb b/tutorial/instrument-specific/CMS/cms-giwaxs_time_series_plotting_example.ipynb new file mode 100644 index 00000000..03a38f88 --- /dev/null +++ b/tutorial/instrument-specific/CMS/cms-giwaxs_time_series_plotting_example.ipynb @@ -0,0 +1,1734 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b3c13da0-ce45-4653-9fb2-5f71078d5a36", + "metadata": {}, + "source": [ + "# CMS GIWAXS plotting notebook" + ] + }, + { + "cell_type": "markdown", + "id": "96625ca6-7ec2-4690-bf01-72b422801f76", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dd667c0e-baba-4a5d-857a-ca8bd5ce1407", + "metadata": {}, + "outputs": [], + "source": [ + "# Imports:\n", + "import pathlib\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import LogNorm\n", + "from tqdm.auto import tqdm \n", + "import subprocess\n", + "import io\n", + "\n", + "\n", + "# Define colormap:\n", + "cmap = plt.cm.turbo\n", + "cmap.set_bad('black')" + ] + }, + { + "cell_type": "markdown", + "id": "7dffa6de-0360-4fcb-b0bf-f320927837d0", + "metadata": { + "tags": [] + }, + "source": [ + "## Define & check paths" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8db0fc93-6739-457a-a7fe-ba695bb41716", + "metadata": {}, + "outputs": [], + "source": [ + "# Using pathlib is currently necessary for the loadSeries function later on, and it's just nice\n", + "# Replace the paths with the ones relevant to your data, you can use the \".exists()\" method to make sure you defined a path correctly\n", + "propPath = pathlib.Path('/nsls2/data/cms/proposals/2023-2/pass-311415') # The proposals path is a good place to store large data\n", + "\n", + "\n", + "# Choose various directories you'll need for your workflow (usually just source and destination folders)\n", + "wliPath = propPath.joinpath('KWhite5/filmetrics_2023C2')\n", + "outPath = propPath.joinpath('AL_processed_data') \n", + "qparasPath = outPath.joinpath('qpara_zarrs')\n", + "qperpsPath = outPath.joinpath('qperp_zarrs')\n", + "seriesPath = outPath.joinpath('series_zarrs')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e4fdac03-46b0-4814-8fed-6b0b3de72404", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['recip_1117893_pybtz_0to10s_qpara_011.zarr',\n", + " 'recip_1117894_pybtz_10to90s_qpara_011.zarr',\n", + " 'recip_1117895_pybtz_90to180s_qpara_011.zarr',\n", + " 'recip_1118200_pybtz_0to10s_qpara_013.zarr',\n", + " 'recip_1118201_pybtz_10to90s_qpara_013.zarr',\n", + " 'recip_1118202_pybtz_90to180s_qpara_013.zarr',\n", + " 'recip_1118329_pybtz_0to10s_qpara_014.zarr',\n", + " 'recip_1118330_pybtz_10to90s_qpara_014.zarr',\n", + " 'recip_1118331_pybtz_90to180s_qpara_014.zarr']" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# List the files inside a folder\n", + "sorted([f.name for f in seriesPath.glob('recip*pybtz*')])" + ] + }, + { + "cell_type": "markdown", + "id": "b04db06b-b932-448d-bb16-33a5acf59804", + "metadata": { + "tags": [] + }, + "source": [ + "## Time-resolved GIWAXS Plotting" + ] + }, + { + "cell_type": "markdown", + "id": "1c1263d8-367b-4b09-b625-7f46bb561e90", + "metadata": { + "tags": [] + }, + "source": [ + "### Cartesian image stack processing" + ] + }, + { + "cell_type": "markdown", + "id": "0eac4af3-129a-4f00-879b-cf3695fee485", + "metadata": {}, + "source": [ + "#### Load zarrs into dataarray" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ddf0b97b-f956-4ab6-a1a5-b0e37dad0c6c", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'DA' (time: 305, q_z: 1043, q_para: 981)>\n",
+       "dask.array<rechunk-merge, shape=(305, 1043, 981), dtype=float32, chunksize=(1, 1043, 981), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * q_para   (q_para) float64 -2.48 -2.475 -2.47 -2.466 ... 2.235 2.24 2.245\n",
+       "  * q_z      (q_z) float64 -1.889 -1.884 -1.88 -1.875 ... 2.963 2.968 2.972\n",
+       "  * time     (time) float64 0.1 0.2 0.3 0.4 0.5 ... 174.0 176.0 178.0 180.0\n",
+       "Attributes: (12/14)\n",
+       "    blade_speed:           40\n",
+       "    concentration:         15\n",
+       "    detector:              maxs.tiff\n",
+       "    exposure_time:         (0.095, 0.495, 1.995)\n",
+       "    gap_height:            200\n",
+       "    incident_angle:        th0.120\n",
+       "    ...                    ...\n",
+       "    scan_id:               1118329\n",
+       "    solution_temperature:  60\n",
+       "    solvent:               CBCNp5\n",
+       "    stage_temperature:     60\n",
+       "    time_start:            544.2s\n",
+       "    x_position_offset:     x0.000
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * q_para (q_para) float64 -2.48 -2.475 -2.47 -2.466 ... 2.235 2.24 2.245\n", + " * q_z (q_z) float64 -1.889 -1.884 -1.88 -1.875 ... 2.963 2.968 2.972\n", + " * time (time) float64 0.1 0.2 0.3 0.4 0.5 ... 174.0 176.0 178.0 180.0\n", + "Attributes: (12/14)\n", + " blade_speed: 40\n", + " concentration: 15\n", + " detector: maxs.tiff\n", + " exposure_time: (0.095, 0.495, 1.995)\n", + " gap_height: 200\n", + " incident_angle: th0.120\n", + " ... ...\n", + " scan_id: 1118329\n", + " solution_temperature: 60\n", + " solvent: CBCNp5\n", + " stage_temperature: 60\n", + " time_start: 544.2s\n", + " x_position_offset: x0.000" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load zarr dataset(s):\n", + "filenames = sorted([f.name for f in seriesPath.glob('recip*pybtz*014*')])\n", + "DA_0to10 = xr.open_zarr(outPath.joinpath('series_zarrs', filenames[0]))['DA']\n", + "DA_10to90 = xr.open_zarr(outPath.joinpath('series_zarrs', filenames[1]))['DA']\n", + "DA_90to180 = xr.open_zarr(outPath.joinpath('series_zarrs', filenames[2]))['DA']\n", + "\n", + "DA_0to10 = DA_0to10.where(DA_0to10>1e-8)\n", + "DA_10to90 = DA_10to90.where(DA_10to90>1e-8)\n", + "DA_90to180 = DA_90to180.where(DA_90to180>1e-8)\n", + "\n", + "# Concatenate into one dataarray along time dimension if necessary\n", + "exposure_times = (0.095, 0.495, 1.995)\n", + "DA = xr.concat([(DA_0to10/exposure_times[0]), (DA_10to90/exposure_times[1]), (DA_90to180/exposure_times[2])], dim='time')\n", + "DA.attrs = DA_0to10.attrs\n", + "DA.attrs['exposure_time'] = exposure_times\n", + "DA = DA.chunk({'time':1, 'q_z':1043, 'q_para': 981}) # optional refine chunking dimensions for smoother operations later\n", + "DA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3fbed9d1-cc9c-4440-a1b0-7c983aa415ce", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Facet plot of selected times\n", + "cmin = float(DA.compute().quantile(1e-2))\n", + "cmax = float(DA.compute().quantile(1-1e-5))\n", + "times = [2, 5, 9, 12, 20, 30, 40, 170]\n", + "\n", + "fg = DA.sel(q_para=slice(-2, 0.7), q_z=slice(-0.01, 2)).sel(time=times, method='nearest').plot.imshow(figsize=(18, 6),\n", + " col='time', col_wrap=4, norm=LogNorm(cmin, cmax), cmap=cmap)\n", + "fg.cbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15)\n", + "for axes in fg.axs.flatten():\n", + " axes.set(aspect='equal')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "56b1e1af-808c-46bd-bed1-32d159a41050", + "metadata": {}, + "source": [ + "#### Generate mp4 movie(s)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ab6ea8cd-2966-4d66-88e4-b9fd7672b5db", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Select plotting parameters, and check plot frame outputs\n", + "q_para_slice = slice(-2, 0.7) \n", + "q_z_slice = slice(-0.01, 2)\n", + "\n", + "\n", + "# Plot some selected frames\n", + "times = [2, 5, 9, 12, 20, 30, 40, 170]\n", + "for time in tqdm(times):\n", + " # Plot\n", + " sliced_DA = DA.sel(time=time,method='nearest')\n", + " sliced_DA = sliced_DA.sel(q_z=q_z_slice, q_para=q_para_slice)\n", + " cmin = float(sliced_DA.compute().quantile(0.01))\n", + " cmax = float(sliced_DA.compute().quantile(0.993))\n", + "\n", + " ax = sliced_DA.plot.imshow(figsize=(5.5, 3.5), cmap=cmap, norm=plt.Normalize(cmin,cmax))\n", + " ax.figure.suptitle(f'Time = {np.round(time, 1)} s', fontsize=14, x=0.52)\n", + " ax.figure.set_tight_layout(True)\n", + " ax.axes.set(aspect='equal', title=f'{DA.material} {DA.solvent}', xlabel='q$_{para}$ [$Å^{-1}$]', ylabel='q$_z$ [$Å^{-1}$]')\n", + " ax.colorbar.set_label('Intensity [arb. units]', rotation=270, labelpad=12)\n", + " plt.show()\n", + " plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ddf960d-b641-4d15-9f80-772d2b691cdc", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# Generate movie for time dataarray:\n", + "savePath = outPath.joinpath('mp4_movies/trgiwaxs')\n", + "output_path = savePath.joinpath(f'{DA.material}_{DA.solvent}.mp4')\n", + "\n", + "# FFmpeg command. This is set up to accept data from the pipe and use it as input, with PNG format.\n", + "# It will then output an H.264 encoded MP4 video.\n", + "cmd = [\n", + " 'ffmpeg',\n", + " '-y', # Overwrite output file if it exists\n", + " '-f', 'image2pipe',\n", + " '-vcodec', 'png',\n", + " '-r', '15', # Frame rate\n", + " '-i', '-', # The input comes from a pipe\n", + " '-vcodec', 'libx264',\n", + " '-pix_fmt', 'yuv420p',\n", + " '-crf', '17', # Set the quality (lower is better, 17 is often considered visually lossless)\n", + " str(output_path)\n", + "]\n", + "\n", + "# Start the subprocess\n", + "proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n", + "\n", + "# Loop through the energy dimension and send frames to FFmpeg\n", + "for i, time in enumerate(tqdm(DA.time.values, desc=f'Compiling frames into mp4')):\n", + " # Make & customize plot\n", + " sliced_DA = DA.sel(time=time,method='nearest')\n", + " sliced_DA = sliced_DA.sel(q_z=q_z_slice, q_para=q_para_slice)\n", + " cmin = float(sliced_DA.compute().quantile(0.01))\n", + " cmax = float(sliced_DA.compute().quantile(0.993))\n", + "\n", + " ax = sliced_DA.plot.imshow(figsize=(5.5, 3.5), cmap=cmap, norm=plt.Normalize(cmin,cmax))\n", + " ax.figure.suptitle(f'Time = {np.round(time, 1)} s', fontsize=14, x=0.52)\n", + " ax.figure.set_tight_layout(True)\n", + " ax.axes.set(aspect='equal', title=f'{DA.material} {DA.solvent}', xlabel='q$_{para}$ [$Å^{-1}$]', ylabel='q$_z$ [$Å^{-1}$]')\n", + " ax.colorbar.set_label('Intensity [arb. units]', rotation=270, labelpad=12)\n", + "\n", + " if i == 0:\n", + " # Save first frame as poster image\n", + " ax.figure.savefig(savePath.joinpath(f'{DA.material}_{DA.solvent}.png'), dpi=120)\n", + "\n", + " buf = io.BytesIO()\n", + " ax.figure.savefig(buf, format='png')\n", + " buf.seek(0)\n", + "\n", + " # Write the PNG buffer data to the process\n", + " proc.stdin.write(buf.getvalue())\n", + " plt.close('all')\n", + "\n", + "# Finish the subprocess\n", + "out, err = proc.communicate()\n", + "if proc.returncode != 0:\n", + " print(f\"Error: {err}\")" + ] + }, + { + "cell_type": "markdown", + "id": "5545a93c-54e0-49f9-a76e-db9e11505c66", + "metadata": { + "tags": [] + }, + "source": [ + "### Polar image stack processing" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "f5fd846c-61fb-4c01-a0ac-baddcefdab04", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'DA' (time: 294, chi: 180, qr: 1000)>\n",
+       "dask.array<rechunk-merge, shape=(294, 180, 1000), dtype=float32, chunksize=(1, 180, 1000), chunktype=numpy.ndarray>\n",
+       "Coordinates:\n",
+       "  * chi      (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n",
+       "  * qr       (qr) float64 0.1695 0.173 0.1766 0.1801 ... 3.714 3.718 3.721 3.725\n",
+       "  * time     (time) float64 0.1 0.2 0.3 0.4 0.5 ... 172.9 174.9 176.9 178.9\n",
+       "Attributes: (12/15)\n",
+       "    blade_speed:           40\n",
+       "    concentration:         15\n",
+       "    detector:              maxs.tiff\n",
+       "    exposure_time:         (0.095, 0.495, 1.995)\n",
+       "    gap_height:            200\n",
+       "    incident_angle:        th0.120\n",
+       "    ...                    ...\n",
+       "    scan_id:               1118329\n",
+       "    solution_temperature:  60\n",
+       "    solvent:               CBCNp5\n",
+       "    stage_temperature:     60\n",
+       "    time_start:            544.2s\n",
+       "    x_position_offset:     x0.000
" + ], + "text/plain": [ + "\n", + "dask.array\n", + "Coordinates:\n", + " * chi (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n", + " * qr (qr) float64 0.1695 0.173 0.1766 0.1801 ... 3.714 3.718 3.721 3.725\n", + " * time (time) float64 0.1 0.2 0.3 0.4 0.5 ... 172.9 174.9 176.9 178.9\n", + "Attributes: (12/15)\n", + " blade_speed: 40\n", + " concentration: 15\n", + " detector: maxs.tiff\n", + " exposure_time: (0.095, 0.495, 1.995)\n", + " gap_height: 200\n", + " incident_angle: th0.120\n", + " ... ...\n", + " scan_id: 1118329\n", + " solution_temperature: 60\n", + " solvent: CBCNp5\n", + " stage_temperature: 60\n", + " time_start: 544.2s\n", + " x_position_offset: x0.000" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load zarr dataset(s):\n", + "filenames = sorted([f.name for f in seriesPath.glob('caked*pybtz*014*')])\n", + "DA_0to10 = xr.open_zarr(outPath.joinpath('series_zarrs', filenames[0])).DA\n", + "DA_10to90 = xr.open_zarr(outPath.joinpath('series_zarrs', filenames[1])).DA\n", + "DA_90to180 = xr.open_zarr(outPath.joinpath('series_zarrs', filenames[2])).DA\n", + "\n", + "DA_0to10 = DA_0to10.where(DA_0to10>1e-8)\n", + "DA_10to90 = DA_10to90.where(DA_10to90>1e-8)\n", + "DA_90to180 = DA_90to180.where(DA_90to180>1e-8)\n", + "\n", + "# Concatenate into one dataarray along time dimension\n", + "exposure_times = (0.095, 0.495, 1.995)\n", + "DA = xr.concat([(DA_0to10/exposure_times[0]), (DA_10to90/exposure_times[1]), (DA_90to180/exposure_times[2])], dim='time')\n", + "DA.attrs = DA_0to10.attrs\n", + "DA.attrs['exposure_time'] = exposure_times\n", + "\n", + "# Add a dictionary so I stop forgetting to change plot titles for CN percent:\n", + "percent_dict = {'CB':0, 'CBCNp1':1, 'CBCNp5':4}\n", + "\n", + "# Optionally remove first few time slices:\n", + "# for my PY-BTz samples: \n", + "tzero_dict = {'CB':0, 'CBCNp1':0.7, 'CBCNp5':1.2}\n", + "tzero = tzero_dict[DA.solvent]\n", + "DA = DA.sel(time=slice(tzero, 400))\n", + "DA['time'] = np.round(DA['time'] - (tzero-0.1), 1)\n", + "DA = DA.chunk({'time':1, 'chi':180, 'qr':1000})\n", + "DA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d4001c33-721f-4a12-b132-1fe54b9e8b67", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Facet plot of selected times, mostly to check clims and that nothing weird is happening\n", + "cmin = float(DA.compute().quantile(1e-2))\n", + "cmax = float(DA.compute().quantile(1-1e-5))\n", + "times = [0, 5, 9, 12, 20, 30, 40, 170]\n", + "\n", + "axs = DA.sel(time=times, method='nearest').sel(chi=slice(-90, 60), qr=slice(0,2)).plot.imshow(figsize=(18,6), col='time', col_wrap=4, norm=LogNorm(cmin, cmax), cmap=cmap)\n", + "plt.show()\n", + "plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fb7c341c-fbc6-4146-803f-3a97f697b7f9", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Select chi regions, zoom into plot to check positions of detector gaps / edges / misc\n", + "OOP_chi_min = 8\n", + "OOP_chi_max = 18\n", + "\n", + "IP_chi_min = -82\n", + "IP_chi_max = -72\n", + "\n", + "OOP_DA = DA.sel(chi=slice(OOP_chi_min, OOP_chi_max))\n", + "OOP_cmin = float(OOP_DA.compute().quantile(1e-2))\n", + "OOP_cmax = float(OOP_DA.compute().quantile(1-1e-5))\n", + "\n", + "IP_DA = DA.sel(chi=slice(IP_chi_min, IP_chi_max))\n", + "IP_cmin = float(IP_DA.compute().quantile(1e-2))\n", + "IP_cmax = float(IP_DA.compute().quantile(1-1e-5))\n", + "\n", + "axs = OOP_DA.sel(time=[10, 70, 100], method='nearest').sel(qr=slice(0.22,2)).plot.imshow(figsize=(15,5),\n", + " col='time', cmap=cmap, norm=LogNorm(OOP_cmin, OOP_cmax), interpolation='antialiased')\n", + "axs.fig.suptitle('Out of Plane Slice', y=1.02)\n", + "\n", + "axs = IP_DA.sel(time=[10, 70, 100], method='nearest').sel(qr=slice(0,2)).plot.imshow(figsize=(15,5),\n", + " col='time', cmap=cmap, norm=LogNorm(IP_cmin, IP_cmax), interpolation='antialiased')\n", + "axs.fig.suptitle('In Plane Slice', y=1.02)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ef63a849-1801-4f45-b74f-da10329a58b9", + "metadata": {}, + "outputs": [], + "source": [ + "# Interpolate detector gaps along a chosen dimension \n", + "plt.close('all')\n", + "method='linear'\n", + "dim='chi'\n", + "interp_DA = DA.compute().interpolate_na(dim=dim, method=method)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7dee14df-348f-4963-963f-6fa145cd80fa", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Plot interpolated region, only necessary when detector gap is not easily to be avoided\n", + "# As seen above, that is only the case for my in my in plane region:\n", + "interp_IP_DA = interp_DA.sel(chi=slice(IP_chi_min, IP_chi_max))\n", + "\n", + "axs = interp_IP_DA.sel(time=[10, 70, 100], method='nearest').sel(qr=slice(0,2)).plot.imshow(figsize=(15,5),\n", + " col='time', cmap=cmap, norm=LogNorm(IP_cmin, IP_cmax))\n", + "axs.fig.suptitle(f'In Plane Slice Interpolated Along {dim}', y=1.02)\n", + "\n", + "plt.show()\n", + "plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "63dc8a98-8722-40ba-9b71-feedb1502a24", + "metadata": {}, + "outputs": [], + "source": [ + "# # Choose and save OOP & IP dataarrays as .csv's if desired\n", + "# OOP_DA.sum('chi').to_pandas().to_csv(outPath.joinpath('tr_OOP-IP', f'{DA.material}-{DA.solvent}_{DA.sample_number}_OOP.csv'))\n", + "# interp_IP_DA.sum('chi').to_pandas().to_csv(outPath.joinpath('tr_OOP-IP', f'{DA.material}-{DA.solvent}_{DA.sample_number}_IP.csv'))" + ] + }, + { + "cell_type": "markdown", + "id": "cb3801ba-ffb7-42be-bbac-625b92596ecc", + "metadata": {}, + "source": [ + "#### Time resolved in plane & out of plane linecuts plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "d73e5f44-08e5-40bf-994e-fda296760ec5", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "924d509cf71543f38828c56788ab7c93", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/141 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot\n", + "time_slice = slice(0,35)\n", + "\n", + "colors = cmap(np.linspace(0,1,len(DA.sel(time=time_slice).time)))\n", + "fig, axs = plt.subplots(1, 2, figsize=(9,3))\n", + "\n", + "for i, time in enumerate(tqdm(DA.sel(time=time_slice).time)):\n", + " # DA.sel(time=time, method='nearest').sel(chi=slice(7, 20), qr=slice(0.2,1.8)).sum('chi').plot.line(ax=axs[0], color=colors[i])\n", + " OOP_DA.sum('chi').sel(time=time, method='nearest').sel(qr=slice(0.2,1.15)).plot.line(ax=axs[0], color=colors[i])\n", + " OOP_DA.sum('chi').sel(time=time, method='nearest').sel(qr=slice(1.31,2)).plot.line(ax=axs[0], color=colors[i])\n", + " interp_IP_DA.sum('chi').sel(time=time, method='nearest').sel(qr=slice(0,2)).plot.line(ax=axs[1], color=colors[i])\n", + " \n", + "# Create a ScalarMappable object with the colormap and normalization & add the colorbar to the figure\n", + "sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin=time_slice.start, vmax=time_slice.stop))\n", + "cax = axs[1].inset_axes([1.03, 0, 0.03, 1])\n", + "cbar = fig.colorbar(sm, cax=cax, orientation='vertical')\n", + "cbar.set_label(label=f'Time [seconds]', labelpad=14)\n", + "cbar.set_ticks(np.linspace(time_slice.start, time_slice.stop, 5).astype('int'))\n", + "\n", + "# More plot customization\n", + "fig.suptitle('PBDB-TF$_{0.25}$:PY-BTz BHJ ' + f'{percent_dict[DA.solvent]}% CN', fontsize=14)\n", + "axs[0].set(xlim=(0.1, 2.05), title=f'OOP: {OOP_chi_min}° to {OOP_chi_max}° Chi', ylabel= 'Intensity [arb. units]', xlabel='q$_r$ [Å$^{-1}$]')\n", + "axs[0].grid(visible=True, which='major', axis='x')\n", + "axs[1].set(xlim=(0.1, 2.05), title=f'IP: {IP_chi_min}° to {IP_chi_max}° Chi (interpolated det. gap)', ylabel='', xlabel='q$_r$ [Å$^{-1}$]')\n", + "axs[1].grid(visible=True, which='major', axis='x')\n", + "\n", + "fig.set(tight_layout=True, dpi=130)\n", + "\n", + "# fig.savefig(outPath.joinpath('trGIWAXS_OOP-IP', f'{DA.material}_{DA.solvent}_{DA.sample_number}_{time_slice.start}to{time_slice.stop}s_linecuts.png'), dpi=150)\n", + "\n", + "plt.show()\n", + "plt.close('all')" + ] + }, + { + "cell_type": "markdown", + "id": "a2291e46-3215-475e-976a-428daae6eaae", + "metadata": {}, + "source": [ + "#### Time resolved in plane & out of plane 2D plotting" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "dda49817-0921-44d5-a7d3-dba5cc58909d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Slice/sum data as needed for IP & OOP DataArrays\n", + "tr_OOP_DA = OOP_DA.sel(qr=slice(0.22,1.85), time=time_slice).sum('chi')\n", + "tr_OOP_DA = tr_OOP_DA.where((tr_OOP_DA.qr<1.15) | (tr_OOP_DA.qr>1.31))\n", + "tr_IP_DA = interp_IP_DA.sel(qr=slice(0.22,1.85), time=time_slice).sum('chi')\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(11,5))\n", + "\n", + "tr_OOP_DA.plot(ax=axs[0], x='time', cmap=cmap, norm=LogNorm(3.7e2, 2.3e3), add_colorbar=False)\n", + "tr_IP_DA.plot(ax=axs[1], x='time', cmap=cmap, norm=LogNorm(2e2, 2.3e3), add_colorbar=False)\n", + "\n", + "# Create a ScalarMappable object with the colormap and normalization & add the colorbar to the figure\n", + "sm = plt.cm.ScalarMappable(cmap=cmap, norm=LogNorm(2e2, 2.3e3))\n", + "cax = axs[1].inset_axes([1.03, 0, 0.05, 1])\n", + "cbar = fig.colorbar(sm, cax=cax, orientation='vertical')\n", + "cbar.set_label(label='Intensity [arb. units]', labelpad=12)\n", + "\n", + "fig.suptitle('PBDB-TF$_{0.25}$:PY-BTz BHJ ' + f'{percent_dict[DA.solvent]}% CN', fontsize=14)\n", + "fig.set(tight_layout=True)\n", + "\n", + "axs[0].set(title=f'OOP: {OOP_chi_min}° to {OOP_chi_max}° Chi', ylabel='q$_r$ [Å$^{-1}$]', xlabel='Time [seconds]')\n", + "axs[1].set(title=f'IP: {IP_chi_min}° to {IP_chi_max}° Chi (interpolated det. gap)', ylabel='q$_r$ [Å$^{-1}$]', xlabel='Time [seconds]')\n", + "\n", + "# fig.savefig(outPath.joinpath('trGIWAXS_OOP-IP', f'{DA.material}_{DA.solvent}_{DA.sample_number}_{time_slice.start}to{time_slice.stop}s_2D-plot.png'), dpi=150)\n", + "\n", + "plt.show()\n", + "plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1c6cf512-a7ac-48fb-bd57-d931ffb9c0ed", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nrss", + "language": "python", + "name": "nrss" + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/instrument-specific/CMS/cms-giwaxs_time_series_processing_example.ipynb b/tutorial/instrument-specific/CMS/cms-giwaxs_time_series_processing_example.ipynb new file mode 100644 index 00000000..f7086f6a --- /dev/null +++ b/tutorial/instrument-specific/CMS/cms-giwaxs_time_series_processing_example.ipynb @@ -0,0 +1,4290 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b3c13da0-ce45-4653-9fb2-5f71078d5a36", + "metadata": {}, + "source": [ + "# CMS GIWAXS raw data processing & exporting notebook - time resolved GIWAXS series measurements\n", + "In this notebook you output xr.DataSets stored as .zarr stores containing all your raw,\n", + "remeshed (reciprocal space), and caked CMS GIWAXS data. Saving as a zarr automatically converts the array to a dask array!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "890da6d6-cd22-4687-a4e8-1166e36cb22d", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# # Outdated, this used to work to just overwrite existing PyHyper install in JupyterHub conda environment\n", + "# # If you need a custom PyHyper version install, you may need your own conda environment\n", + "\n", + "# # Kernel updates if needed, remember to restart kernel after running this cell!:\n", + "# !pip install -e /nsls2/users/alevin/repos/PyHyperScattering # to use pip to install via directory" + ] + }, + { + "cell_type": "markdown", + "id": "96625ca6-7ec2-4690-bf01-72b422801f76", + "metadata": {}, + "source": [ + "# Imports" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dd667c0e-baba-4a5d-857a-ca8bd5ce1407", + "metadata": {}, + "outputs": [], + "source": [ + "### Imports:\n", + "import pathlib\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.colors import LogNorm\n", + "import xarray as xr\n", + "import PyHyperScattering as phs\n", + "import pygix\n", + "import gc\n", + "from tqdm.auto import tqdm # progress bar loader!\n", + "\n", + "print(f'Using PyHyperScattering Version: {phs.__version__}')\n", + "\n", + "# Set colormap\n", + "cmap = plt.cm.turbo.copy()\n", + "cmap.set_bad('black')" + ] + }, + { + "cell_type": "markdown", + "id": "7dffa6de-0360-4fcb-b0bf-f320927837d0", + "metadata": { + "tags": [] + }, + "source": [ + "# Defining some objects" + ] + }, + { + "cell_type": "markdown", + "id": "b36b6f6c-4643-46b3-9784-9a6071c754ba", + "metadata": {}, + "source": [ + "## Define & check paths" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8db0fc93-6739-457a-a7fe-ba695bb41716", + "metadata": {}, + "outputs": [], + "source": [ + "# I like pathlib for its readability & checkability, it's also necessary for the loadSeries function later on\n", + "# Replace the paths with the ones relevant to your data, you can use the \".exists()\" method to make sure you defined a path correctly\n", + "userPath = pathlib.Path('/nsls2/users/alevin') # Your users path is great for small items that are personal to you (100 GB limit)\n", + "propPath = pathlib.Path('/nsls2/data/cms/proposals/2023-2/pass-311415') # The proposals path is a good place to store large data (>1 TB space?)\n", + "dataPath = propPath.joinpath('KWhite5')\n", + "maskponiPath = userPath.joinpath('giwaxs_suite/beamline_data/maskponi')\n", + "outPath = propPath.joinpath('AL_processed_data')\n", + "\n", + "# Select poni & mask filepaths\n", + "poniFile = maskponiPath.joinpath('LaB6_fixed_rot_x517.2.poni')\n", + "maskFile = maskponiPath.joinpath('LaB6.json')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4fdac03-46b0-4814-8fed-6b0b3de72404", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# List the files inside the dataPath folder\n", + "sorted([f.name for f in dataPath.iterdir()]) # list all filenames inside a path" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "161af719-785d-4555-b715-b5c60d0330a2", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# Select a time series sample folder from above list\n", + "\n", + "sample = 'pybtz_CBCNp5_15_200_40_60_60_014'\n", + "samplePath = dataPath.joinpath(sample, 'maxs/raw')\n", + "# sorted([f.name for f in samplePath.iterdir()]) # list all filenames inside a path" + ] + }, + { + "cell_type": "markdown", + "id": "fb6a356d-2931-4da7-83e5-741d8a4bf11d", + "metadata": {}, + "source": [ + "## Define sets/lists of filtered filepaths" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9871d3d3-4133-4d26-8474-3b7f9580509d", + "metadata": { + "scrolled": true, + "tags": [] + }, + "outputs": [], + "source": [ + "# Generate sets for samples with multiple scan ids per series scan\n", + "# Some of my series are broken into different scan ids because I changed the exposure time\n", + "\n", + "# Choose series scan id(s)\n", + "series_ids = ['1118329', '1118330', '1118331']\n", + "\n", + "# Create separate sets for single vs series measurements, customize per your data:\n", + "# I had 3 different scan ids in one series measurement, so I combine them all first \n", + "# before substracting them from the total file list\n", + "exp0p1_set = set(samplePath.glob(f'*{series_ids[0]}*')) \n", + "exp0p5_set = set(samplePath.glob(f'*{series_ids[1]}*'))\n", + "exp2p0_set = set(samplePath.glob(f'*{series_ids[2]}*'))\n", + "qperp_set = set(samplePath.glob('*qperp*'))\n", + "\n", + "series_set = exp0p1_set.union(exp0p5_set, exp2p0_set)\n", + "singles_set = set(samplePath.iterdir()).difference(series_set)\n", + "qpara_set = singles_set.difference(qperp_set)\n", + "\n", + "# # Check content of sets\n", + "# print('qperp images:')\n", + "# display(sorted([f.name for f in qperp_set]))\n", + "\n", + "# print('\\nqpara images:')\n", + "# display(sorted([f.name for f in qpara_set]))\n", + "\n", + "# print('\\nimage series:')\n", + "# display(sorted([f.name for f in series_set]))" + ] + }, + { + "cell_type": "markdown", + "id": "c1840638-1577-4dea-8819-ffb69d6f80b8", + "metadata": {}, + "source": [ + "## Define metadata naming schemes & initialize loaders" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "fdd31494-d2e4-43d7-adce-d31098c55edb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Filename: pybtz_CBCNp5_15_200_40_60_60_014_1005.1s_x3.002_th0.100_5.00s_1118375_maxs.tiff\n", + "('material', 'pybtz')\n", + "('solvent', 'CBCNp5')\n", + "('concentration', '15')\n", + "('gap_height', '200')\n", + "('blade_speed', '40')\n", + "('solution_temperature', '60')\n", + "('stage_temperature', '60')\n", + "('sample_number', '014')\n", + "('time_start', '1005.1s')\n", + "('x_position_offset', 'x3.002')\n", + "('incident_angle', 'th0.100')\n", + "('exposure_time', '5.00s')\n", + "('scan_id', '1118375')\n", + "('detector', 'maxs.tiff')\n", + "\n", + "Filename: pybtz_CBCNp5_15_200_40_60_60_014_qperp_1586.6s_x-2.001_th0.100_5.00s_1118405_maxs.tiff\n", + "('material', 'pybtz')\n", + "('solvent', 'CBCNp5')\n", + "('concentration', '15')\n", + "('gap_height', '200')\n", + "('blade_speed', '40')\n", + "('solution_temperature', '60')\n", + "('stage_temperature', '60')\n", + "('sample_number', '014')\n", + "('in-plane_orientation', 'qperp')\n", + "('time_start', '1586.6s')\n", + "('x_position_offset', 'x-2.001')\n", + "('incident_angle', 'th0.100')\n", + "('exposure_time', '5.00s')\n", + "('scan_id', '1118405')\n", + "('detector', 'maxs.tiff')\n", + "\n", + "Filename: pybtz_CBCNp5_15_200_40_60_60_014_544.2s_x0.000_th0.120_0.10s_1118329_000000_maxs.tiff\n", + "('material', 'pybtz')\n", + "('solvent', 'CBCNp5')\n", + "('concentration', '15')\n", + "('gap_height', '200')\n", + "('blade_speed', '40')\n", + "('solution_temperature', '60')\n", + "('stage_temperature', '60')\n", + "('sample_number', '014')\n", + "('time_start', '544.2s')\n", + "('x_position_offset', 'x0.000')\n", + "('incident_angle', 'th0.120')\n", + "('exposure_time', '0.10s')\n", + "('scan_id', '1118329')\n", + "('series_number', '000000')\n", + "('detector', 'maxs.tiff')\n" + ] + } + ], + "source": [ + "# My example metadata filename naming schemes:\n", + "# Make sure the length of this list lines up with your filenames split by underscore (or however you split them)!\n", + "\n", + "# Metadata naming schemes for the pybtz samples\n", + "# For nonrotated, qpara images:\n", + "qpara_md_naming_scheme = ['material', 'solvent', 'concentration', 'gap_height', 'blade_speed',\n", + " 'solution_temperature', 'stage_temperature', 'sample_number', 'time_start',\n", + " 'x_position_offset', 'incident_angle', 'exposure_time', 'scan_id', 'detector']\n", + "\n", + "# For rotated, qperp images:\n", + "qperp_md_naming_scheme = ['material', 'solvent', 'concentration', 'gap_height', 'blade_speed',\n", + " 'solution_temperature', 'stage_temperature', 'sample_number', 'in-plane_orientation',\n", + " 'time_start', 'x_position_offset', 'incident_angle', 'exposure_time', 'scan_id', 'detector']\n", + "\n", + "# For in situ series images:\n", + "series_md_naming_scheme = ['material', 'solvent', 'concentration', 'gap_height', 'blade_speed',\n", + " 'solution_temperature', 'stage_temperature', 'sample_number', 'time_start',\n", + " 'x_position_offset', 'incident_angle', 'exposure_time', 'scan_id', \n", + " 'series_number', 'detector']\n", + "\n", + "# A way to check our naming schemes to make sure they're right:\n", + "delim = '_'\n", + "file_sets = [ qpara_set, qperp_set, series_set]\n", + "file_schemes = [qpara_md_naming_scheme, qperp_md_naming_scheme, series_md_naming_scheme]\n", + "\n", + "for file_set, file_scheme in zip(file_sets, file_schemes):\n", + " first_filename = sorted(file_set)[0].name\n", + " print(f'\\nFilename: {first_filename}')\n", + " first_filename_list = first_filename.split(delim)\n", + " for tup in zip(file_scheme, first_filename_list):\n", + " print(tup)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "a341590a-9e34-4f3c-a081-e59ad528a3a2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Initalize CMSGIWAXSLoader objects with the above naming schemes\n", + "qpara_loader = phs.load.CMSGIWAXSLoader(md_naming_scheme=qpara_md_naming_scheme)\n", + "qperp_loader = phs.load.CMSGIWAXSLoader(md_naming_scheme=qperp_md_naming_scheme)\n", + "series_loader = phs.load.CMSGIWAXSLoader(md_naming_scheme=series_md_naming_scheme)" + ] + }, + { + "cell_type": "markdown", + "id": "89d72a19-8729-4ebd-914a-9cba20016a72", + "metadata": { + "tags": [] + }, + "source": [ + "# Data processing" + ] + }, + { + "cell_type": "markdown", + "id": "64998ce1-20eb-4a28-95d0-ef506b91166f", + "metadata": {}, + "source": [ + "## Single image scans outside of series measurement\n", + "Using same single_images_to_dataset function as in the single image processing example notebook\n", + "Break up sets below according to your data" + ] + }, + { + "cell_type": "markdown", + "id": "9ca204fc-4388-4319-a910-10cdffb78934", + "metadata": { + "tags": [] + }, + "source": [ + "### qperp set:" + ] + }, + { + "cell_type": "markdown", + "id": "6d87b0d2-2681-43bf-8e76-08abd1c6a0e8", + "metadata": {}, + "source": [ + "#### intialize integrators" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40072c56-e7ec-4612-9b5a-b5132d9af9d8", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "qperp_recip_integrator = phs.integrate.PGGeneralIntegrator(geomethod = 'ponifile',\n", + " ponifile = poniFile,\n", + " output_space = 'recip',\n", + " inplane_config = 'q_perp')\n", + "qperp_caked_integrator = phs.integrate.PGGeneralIntegrator(geomethod = 'ponifile',\n", + " ponifile = poniFile,\n", + " output_space = 'caked',\n", + " inplane_config = 'q_perp')" + ] + }, + { + "cell_type": "markdown", + "id": "4ccef0cd-707c-4f39-9417-b601f9b9b9fe", + "metadata": {}, + "source": [ + "#### generate, check, save: recip Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "55be1bd6-c3ab-4c8d-9372-805e66fa8db3", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "eaa5866671de4956918c6ce8a95721f0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Transforming Raw Data: 0%| | 0/29 [00:00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (q_z: 1043, q_perp: 981)\n",
+       "Coordinates:\n",
+       "  * q_z      (q_z) float64 -1.889 -1.885 -1.88 -1.875 ... 2.963 2.968 2.972\n",
+       "  * q_perp   (q_perp) float64 -2.48 -2.475 -2.47 -2.466 ... 2.235 2.24 2.245\n",
+       "Data variables: (12/30)\n",
+       "    1118405  (q_z, q_perp) float32 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118406  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118407  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118408  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118409  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118410  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    ...       ...\n",
+       "    1118429  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118430  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118431  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118432  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118433  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118434  (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
" + ], + "text/plain": [ + "\n", + "Dimensions: (q_z: 1043, q_perp: 981)\n", + "Coordinates:\n", + " * q_z (q_z) float64 -1.889 -1.885 -1.88 -1.875 ... 2.963 2.968 2.972\n", + " * q_perp (q_perp) float64 -2.48 -2.475 -2.47 -2.466 ... 2.235 2.24 2.245\n", + "Data variables: (12/30)\n", + " 1118405 (q_z, q_perp) float32 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118406 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118407 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118408 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118409 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118410 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " ... ...\n", + " 1118429 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118430 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118431 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118432 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118433 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118434 (q_z, q_perp) float64 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use the single_images_to_dataset utility function to pygix transform all raw files in an indexable list\n", + "# Located in the IntegrationUtils script, CMSGIWAXS class:\n", + "\n", + "# Initalize CMSGIWAXS util object\n", + "util = phs.util.IntegrationUtils.CMSGIWAXS(sorted(qperp_set), qperp_loader, qperp_recip_integrator)\n", + "raw_DS, recip_DS = util.single_images_to_dataset() # run function \n", + "display(recip_DS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b405bdb9-8282-4c94-9250-ee62087fffd4", + "metadata": {}, + "outputs": [], + "source": [ + "# # Example of a quick plot check if desired here:\n", + "# for DA in tqdm(recip_DS.data_vars.values()): \n", + "# cmin = 1\n", + "# cmax = DA.quantile(0.999)\n", + " \n", + "# ax = DA.sel(q_perp=slice(-1.1, 2.1), q_z=slice(-0.05, 2.4)).plot.imshow(cmap=cmap, norm=plt.Normalize(cmin, cmax), figsize=(8,4))\n", + "# ax.axes.set(aspect='equal', title=f'{DA.material}, incident angle: {DA.incident_angle}, scan id: {DA.scan_id}')\n", + "# plt.show()\n", + "# plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3a6e0446-0af7-47fc-9df6-f65e4697c955", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Saving dataset with xarray's to_zarr() method:\n", + "# # General structure below:\n", + "\n", + "# # Set where to save file and what to name it\n", + "# savePath = outPath.joinpath('testing_zarrs')\n", + "# savePath.mkdir(exist_ok=True)\n", + "# savename = 'custom_save_name.zarr'\n", + "\n", + "# # Save it\n", + "# recip_DS.to_zarr(savePath.joinpath(savename))" + ] + }, + { + "cell_type": "markdown", + "id": "d9ed664c-c9b2-46d5-b17b-b8b5d8750716", + "metadata": { + "tags": [] + }, + "source": [ + "#### generate, check, save: caked Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "1a16c744-5a73-4c93-aa47-d156086cae61", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3fd09cd870e1435baea310252d9b63d5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Transforming Raw Data: 0%| | 0/29 [00:00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:  (chi: 180, qr: 1000)\n",
+       "Coordinates:\n",
+       "  * chi      (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n",
+       "  * qr       (qr) float64 0.0001473 0.003876 0.007604 ... 3.717 3.721 3.725\n",
+       "Data variables: (12/30)\n",
+       "    1118405  (chi, qr) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118406  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118407  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118408  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118409  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118410  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    ...       ...\n",
+       "    1118429  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118430  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118431  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118432  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118433  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n",
+       "    1118434  (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0
" + ], + "text/plain": [ + "\n", + "Dimensions: (chi: 180, qr: 1000)\n", + "Coordinates:\n", + " * chi (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n", + " * qr (qr) float64 0.0001473 0.003876 0.007604 ... 3.717 3.721 3.725\n", + "Data variables: (12/30)\n", + " 1118405 (chi, qr) float32 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118406 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118407 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118408 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118409 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118410 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " ... ...\n", + " 1118429 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118430 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118431 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118432 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118433 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0\n", + " 1118434 (chi, qr) float64 0.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 0.0" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Use the single_images_to_dataset function to pygix transform all raw files in an indexable list\n", + "\n", + "# Run function, generate caked reciprocal space output\n", + "raw_DS, caked_DS = phs.PGGeneralIntegrator.single_images_to_dataset(sorted(qperp_set), qperp_loader, qperp_caked_integrator)\n", + "display(caked_DS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f39dc0a2-27cd-4f05-9cb7-1d560ca8557c", + "metadata": {}, + "outputs": [], + "source": [ + "# # Example of a quick plot check if desired here:\n", + "# for DA in tqdm(caked_DS.data_vars.values()): \n", + "# cmin = DA.quantile(0.01)\n", + "# cmax = DA.quantile(0.99)\n", + " \n", + "# ax = DA.plot.imshow(cmap=cmap, norm=plt.Normalize(cmin, cmax), figsize=(8,4))\n", + "# ax.axes.set(title=f'{DA.material}, incident angle: {DA.incident_angle}, scan id: {DA.scan_id}')\n", + "# plt.show()\n", + "# plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ec6ebd2d-84e4-48e0-b95c-82258a441d1b", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Saving dataset with xarray's to_zarr() method:\n", + "# # General structure below:\n", + "\n", + "# # Set where to save file and what to name it\n", + "# savePath = outPath.joinpath('testing_zarrs')\n", + "# savePath.mkdir(exist_ok=True)\n", + "# savename = 'custom_save_name.zarr'\n", + "\n", + "# # Save it\n", + "# caked_DS.to_zarr(savePath.joinpath(savename))" + ] + }, + { + "cell_type": "markdown", + "id": "7003af8d-9963-4c1f-8339-0296090417da", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "### qpara set:" + ] + }, + { + "cell_type": "markdown", + "id": "9024d629-2cba-4d20-9550-9d16712b3b27", + "metadata": { + "tags": [] + }, + "source": [ + "#### intialize integrators" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "56c33ead-9d48-43b4-9314-f2da756b98e2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "template_xr = qpara_loader.loadSingleImage(sorted(qpara_set)[-1])\n", + "qpara_recip_integrator = phs.integrate.PGGeneralIntegrator(geomethod = 'ponifile',\n", + " ponifile = poniFile,\n", + " output_space = 'recip',\n", + " template_xr = template_xr,\n", + " inplane_config = 'q_para')\n", + "qpara_caked_integrator = phs.integrate.PGGeneralIntegrator(geomethod = 'ponifile',\n", + " ponifile = poniFile,\n", + " output_space = 'caked',\n", + " template_xr = template_xr,\n", + " inplane_config = 'q_para')" + ] + }, + { + "cell_type": "markdown", + "id": "cfcf3834-63fa-4e57-bb4e-cf28061961b3", + "metadata": { + "tags": [] + }, + "source": [ + "#### generate, check, save: recip Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "561f1696-f36f-4a91-9533-aa2746c858f6", + "metadata": {}, + "outputs": [], + "source": [ + "# Use the single_images_to_dataset utility function to pygix transform all raw files in an indexable list\n", + "# Located in the IntegrationUtils script, CMSGIWAXS class:\n", + "\n", + "# Initalize CMSGIWAXS util object\n", + "util = phs.util.IntegrationUtils.CMSGIWAXS(sorted(qpara_set), qpara_loader, qpara_recip_integrator)\n", + "raw_DS, recip_DS = util.single_images_to_dataset() # run function \n", + "display(recip_DS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6baa8a63-bdae-4e8a-b126-23d2a981f2cc", + "metadata": {}, + "outputs": [], + "source": [ + "# # Example of a quick plot check if desired here:\n", + "# for DA in tqdm(list(recip_DS.data_vars.values())[::8]): \n", + "# ax = DA.sel(q_para=slice(-1.1, 2.1), q_z=slice(-0.05, 2.4)).plot.imshow(cmap=cmap, norm=plt.Normalize(50, 1000), figsize=(8,4))\n", + "# ax.axes.set(aspect='equal', title=f'{DA.material}, incident angle: {DA.incident_angle}, scan id: {DA.scan_id}')\n", + "# plt.show()\n", + "# plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "baed0eeb-8138-4d81-902a-e1ba6d7658cb", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Saving dataset with xarray's to_zarr() method:\n", + "# # General structure below:\n", + "\n", + "# # Set where to save file and what to name it\n", + "# savePath = outPath.joinpath('testing_zarrs')\n", + "# savePath.mkdir(exist_ok=True)\n", + "# savename = 'custom_save_name.zarr'\n", + "\n", + "# # Save it\n", + "# recip_DS.to_zarr(savePath.joinpath(savename))" + ] + }, + { + "cell_type": "markdown", + "id": "f1b50c5d-1cf1-4c32-b327-a39523922562", + "metadata": { + "tags": [] + }, + "source": [ + "#### generate, check, save: caked Dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "769b32ad-e108-46d5-8654-42849811c211", + "metadata": {}, + "outputs": [], + "source": [ + "# Use the single_images_to_dataset utility function to pygix transform all raw files in an indexable list\n", + "# Located in the IntegrationUtils script, CMSGIWAXS class:\n", + "\n", + "# Initalize CMSGIWAXS util object\n", + "util = phs.util.IntegrationUtils.CMSGIWAXS(sorted(qpara_set), qpara_loader, qpara_caked_integrator)\n", + "raw_DS, caked_DS = util.single_images_to_dataset() # run function \n", + "display(caked_DS)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0cf082b9-fb6b-4413-9857-86ba02f1231c", + "metadata": {}, + "outputs": [], + "source": [ + "# # Example of a quick plot check if desired here:\n", + "# for DA in tqdm(caked_DS.data_vars.values()): \n", + "# cmin = DA.quantile(0.01)\n", + "# cmax = DA.quantile(0.99)\n", + " \n", + "# ax = DA.plot.imshow(cmap=cmap, norm=plt.Normalize(cmin, cmax), figsize=(8,4))\n", + "# ax.axes.set(title=f'{DA.material}, incident angle: {DA.incident_angle}, scan id: {DA.scan_id}')\n", + "# plt.show()\n", + "# plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c581fac0-39f7-4663-bed2-fac52e1fc35f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Saving dataset with xarray's to_zarr() method:\n", + "# # General structure below:\n", + "\n", + "# # Set where to save file and what to name it\n", + "# savePath = outPath.joinpath('testing_zarrs')\n", + "# savePath.mkdir(exist_ok=True)\n", + "# savename = 'custom_save_name.zarr'\n", + "\n", + "# # Save it\n", + "# caked_DS.to_zarr(savePath.joinpath(savename))" + ] + }, + { + "cell_type": "markdown", + "id": "a72c8af7-0ff8-4e97-baed-7407423c9424", + "metadata": { + "tags": [] + }, + "source": [ + "### Series measurement processing" + ] + }, + { + "cell_type": "markdown", + "id": "0834ff7d-9a80-4df4-9f47-7bdc31470764", + "metadata": { + "tags": [] + }, + "source": [ + "#### Load file series & check raw DataArray" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "16a7da7f-960b-4dbf-998c-1506bc6a0749", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check which files you will select by using a given file_filter below\n", + "file_filter = '0.10s_1118329'\n", + "len([f.name for f in sorted(samplePath.glob(f'*{file_filter}*'))])" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "9b463c4a-9ee2-4067-ace1-c8bb1436a421", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Found 415 total files.\n", + "Found 100 files after applying 'file_filter'.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "efcf41e858d640809383b830466a0f12", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00:200: RuntimeWarning: invalid value encountered in cast\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (pix_y: 1043, pix_x: 981, time: 100)>\n",
+       "array([[[ 0,  0,  0, ...,  2,  3,  0],\n",
+       "        [ 0,  0,  1, ...,  1,  1,  0],\n",
+       "        [ 0,  0,  1, ...,  0,  1,  1],\n",
+       "        ...,\n",
+       "        [ 0,  1,  0, ...,  1,  1,  3],\n",
+       "        [ 0,  1,  0, ...,  1,  1,  1],\n",
+       "        [ 1,  0,  0, ...,  1,  0,  2]],\n",
+       "\n",
+       "       [[ 0,  1,  0, ...,  2,  1,  1],\n",
+       "        [ 0,  3,  1, ...,  1,  0,  1],\n",
+       "        [ 0,  0,  0, ...,  3,  1,  0],\n",
+       "        ...,\n",
+       "        [ 0,  0,  0, ...,  2,  3,  0],\n",
+       "        [ 0,  0,  1, ...,  1,  1,  2],\n",
+       "        [ 0,  0,  0, ...,  2,  2,  3]],\n",
+       "\n",
+       "       [[ 1,  0,  1, ...,  2,  0,  1],\n",
+       "        [ 0,  1,  0, ...,  2,  1,  3],\n",
+       "        [ 0,  0,  2, ...,  3,  0,  1],\n",
+       "        ...,\n",
+       "...\n",
+       "        ...,\n",
+       "        [-2, -2, -2, ..., -2, -2, -2],\n",
+       "        [-2, -2, -2, ..., -2, -2, -2],\n",
+       "        [-2, -2, -2, ..., -2, -2, -2]],\n",
+       "\n",
+       "       [[ 0,  0,  0, ...,  0,  0,  0],\n",
+       "        [ 1,  0,  0, ...,  0,  0,  0],\n",
+       "        [ 0,  0,  1, ...,  0,  2,  0],\n",
+       "        ...,\n",
+       "        [-2, -2, -2, ..., -2, -2, -2],\n",
+       "        [-2, -2, -2, ..., -2, -2, -2],\n",
+       "        [-2, -2, -2, ..., -2, -2, -2]],\n",
+       "\n",
+       "       [[ 1,  0,  0, ...,  0,  0,  0],\n",
+       "        [ 1,  0,  0, ...,  0,  0,  1],\n",
+       "        [ 0,  0,  1, ...,  0,  1,  1],\n",
+       "        ...,\n",
+       "        [-2, -2, -2, ..., -2, -2, -2],\n",
+       "        [-2, -2, -2, ..., -2, -2, -2],\n",
+       "        [-2, -2, -2, ..., -2, -2, -2]]], dtype=int32)\n",
+       "Coordinates:\n",
+       "    series_number  (time) object '000000' '000001' ... '000098' '000099'\n",
+       "  * pix_x          (pix_x) int64 0 1 2 3 4 5 6 7 ... 974 975 976 977 978 979 980\n",
+       "  * pix_y          (pix_y) int64 0 1 2 3 4 5 6 ... 1037 1038 1039 1040 1041 1042\n",
+       "  * time           (time) float64 0.1 0.2 0.3 0.4 0.5 ... 9.6 9.7 9.8 9.9 10.0\n",
+       "Attributes: (12/16)\n",
+       "    material:              pybtz\n",
+       "    solvent:               CBCNp5\n",
+       "    concentration:         15\n",
+       "    gap_height:            200\n",
+       "    blade_speed:           40\n",
+       "    solution_temperature:  60\n",
+       "    ...                    ...\n",
+       "    incident_angle:        th0.120\n",
+       "    exposure_time:         0.10s\n",
+       "    scan_id:               1118329\n",
+       "    series_number:         000000\n",
+       "    detector:              maxs.tiff\n",
+       "    dims_unpacked:         ['series_number']
" + ], + "text/plain": [ + "\n", + "array([[[ 0, 0, 0, ..., 2, 3, 0],\n", + " [ 0, 0, 1, ..., 1, 1, 0],\n", + " [ 0, 0, 1, ..., 0, 1, 1],\n", + " ...,\n", + " [ 0, 1, 0, ..., 1, 1, 3],\n", + " [ 0, 1, 0, ..., 1, 1, 1],\n", + " [ 1, 0, 0, ..., 1, 0, 2]],\n", + "\n", + " [[ 0, 1, 0, ..., 2, 1, 1],\n", + " [ 0, 3, 1, ..., 1, 0, 1],\n", + " [ 0, 0, 0, ..., 3, 1, 0],\n", + " ...,\n", + " [ 0, 0, 0, ..., 2, 3, 0],\n", + " [ 0, 0, 1, ..., 1, 1, 2],\n", + " [ 0, 0, 0, ..., 2, 2, 3]],\n", + "\n", + " [[ 1, 0, 1, ..., 2, 0, 1],\n", + " [ 0, 1, 0, ..., 2, 1, 3],\n", + " [ 0, 0, 2, ..., 3, 0, 1],\n", + " ...,\n", + "...\n", + " ...,\n", + " [-2, -2, -2, ..., -2, -2, -2],\n", + " [-2, -2, -2, ..., -2, -2, -2],\n", + " [-2, -2, -2, ..., -2, -2, -2]],\n", + "\n", + " [[ 0, 0, 0, ..., 0, 0, 0],\n", + " [ 1, 0, 0, ..., 0, 0, 0],\n", + " [ 0, 0, 1, ..., 0, 2, 0],\n", + " ...,\n", + " [-2, -2, -2, ..., -2, -2, -2],\n", + " [-2, -2, -2, ..., -2, -2, -2],\n", + " [-2, -2, -2, ..., -2, -2, -2]],\n", + "\n", + " [[ 1, 0, 0, ..., 0, 0, 0],\n", + " [ 1, 0, 0, ..., 0, 0, 1],\n", + " [ 0, 0, 1, ..., 0, 1, 1],\n", + " ...,\n", + " [-2, -2, -2, ..., -2, -2, -2],\n", + " [-2, -2, -2, ..., -2, -2, -2],\n", + " [-2, -2, -2, ..., -2, -2, -2]]], dtype=int32)\n", + "Coordinates:\n", + " series_number (time) object '000000' '000001' ... '000098' '000099'\n", + " * pix_x (pix_x) int64 0 1 2 3 4 5 6 7 ... 974 975 976 977 978 979 980\n", + " * pix_y (pix_y) int64 0 1 2 3 4 5 6 ... 1037 1038 1039 1040 1041 1042\n", + " * time (time) float64 0.1 0.2 0.3 0.4 0.5 ... 9.6 9.7 9.8 9.9 10.0\n", + "Attributes: (12/16)\n", + " material: pybtz\n", + " solvent: CBCNp5\n", + " concentration: 15\n", + " gap_height: 200\n", + " blade_speed: 40\n", + " solution_temperature: 60\n", + " ... ...\n", + " incident_angle: th0.120\n", + " exposure_time: 0.10s\n", + " scan_id: 1118329\n", + " series_number: 000000\n", + " detector: maxs.tiff\n", + " dims_unpacked: ['series_number']" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Load file series\n", + "stacked_dim = 'series_number' # must be a unique attribute for in each loaded DataArray\n", + "loaded_DA = series_loader.loadFileSeries(basepath=samplePath, dims=['series_number'], file_filter=file_filter) # ensure that your basepath + file_filter selects the filepaths of interest\n", + "# NOTE: CMSGIWAXSLoader.loadSeries() is the deprecated method for this. That method accepts either a basepath + filter OR an iterable of filepaths. More details at end of notebook.\n", + "\n", + "# Create coordinates to apply to stacked dimension\n", + "time_start = 0\n", + "exp_time = np.round(float(loaded_DA.attrs['exposure_time'][:-1]), 1)\n", + "times = loaded_DA.coords['series_number'].data.astype('float')*exp_time + exp_time + time_start\n", + "\n", + "# Remove system dimension (leftover from generalized stacking), assign desired coordinate to stacked dimension, and set it as the stacked dimension\n", + "raw_DA = loaded_DA.unstack('system')\n", + "raw_DA = raw_DA.assign_coords({'time': ('series_number', times)})\n", + "raw_DA = raw_DA.swap_dims({'series_number': 'time'})\n", + "display(raw_DA)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cbc7285b-0acc-421e-858b-ed1a60cd0037", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Quick facet plot of selected times\n", + "cmin=1\n", + "cmax=10\n", + "times = np.linspace(0.1, 10, 8)\n", + "\n", + "sliced_DA = raw_DA.sel(time=times, method='nearest')\n", + "fg = sliced_DA.plot.imshow(figsize=(18, 6), col='time', col_wrap=4, norm=plt.Normalize(cmin, cmax), cmap=cmap, origin='upper')\n", + "fg.cbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15)\n", + "for axes in fg.axs.flatten():\n", + " axes.set(aspect='equal')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "7fb48100-9308-49e1-b23c-43fbf9ed1fc0", + "metadata": { + "tags": [] + }, + "source": [ + "#### Transform data to reciprocal space: cartesian (recip)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0c157e4-1c2b-41ad-b2ec-ddb49b7a97d2", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Reinitialize cartesian integrator if necessary\n", + "# incident angle should be set here (default is 0.12 if nothing is entered)\n", + "qpara_recip_integrator = phs.integrate.PGGeneralIntegrator(geomethod = 'ponifile',\n", + " ponifile = poniFile,\n", + " output_space = 'recip',\n", + " inplane_config = 'q_para',\n", + " incident_angle = 0.12)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "94d1f640-bd06-4b0e-9b06-ac49ad7f5095", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6346e1a0abec406081638357d156bf89", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 100, q_z: 1043, q_para: 981)>\n",
+       "array([[[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "...\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]]], dtype=float32)\n",
+       "Coordinates:\n",
+       "  * q_z      (q_z) float64 -1.889 -1.885 -1.88 -1.875 ... 2.963 2.968 2.972\n",
+       "  * q_para   (q_para) float64 -2.48 -2.475 -2.47 -2.466 ... 2.235 2.24 2.245\n",
+       "  * time     (time) float64 0.1 0.2 0.3 0.4 0.5 0.6 ... 9.5 9.6 9.7 9.8 9.9 10.0\n",
+       "Attributes: (12/16)\n",
+       "    material:              pybtz\n",
+       "    solvent:               CBCNp5\n",
+       "    concentration:         15\n",
+       "    gap_height:            200\n",
+       "    blade_speed:           40\n",
+       "    solution_temperature:  60\n",
+       "    ...                    ...\n",
+       "    incident_angle:        th0.120\n",
+       "    exposure_time:         0.10s\n",
+       "    scan_id:               1118329\n",
+       "    series_number:         000000\n",
+       "    detector:              maxs.tiff\n",
+       "    dims_unpacked:         ['series_number']
" + ], + "text/plain": [ + "\n", + "array([[[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + "...\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]]], dtype=float32)\n", + "Coordinates:\n", + " * q_z (q_z) float64 -1.889 -1.885 -1.88 -1.875 ... 2.963 2.968 2.972\n", + " * q_para (q_para) float64 -2.48 -2.475 -2.47 -2.466 ... 2.235 2.24 2.245\n", + " * time (time) float64 0.1 0.2 0.3 0.4 0.5 0.6 ... 9.5 9.6 9.7 9.8 9.9 10.0\n", + "Attributes: (12/16)\n", + " material: pybtz\n", + " solvent: CBCNp5\n", + " concentration: 15\n", + " gap_height: 200\n", + " blade_speed: 40\n", + " solution_temperature: 60\n", + " ... ...\n", + " incident_angle: th0.120\n", + " exposure_time: 0.10s\n", + " scan_id: 1118329\n", + " series_number: 000000\n", + " detector: maxs.tiff\n", + " dims_unpacked: ['series_number']" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Apply integrator to integrate the raw image stack\n", + "recip_DA = qpara_recip_integrator.integrateImageStack(raw_DA)\n", + "display(recip_DA)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ede59fa-9b82-44d7-8158-cd64e13e3f6f", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Facet plot of selected times\n", + "cmin = 1\n", + "cmax = 10\n", + "times = np.linspace(0.1, 10, 8)\n", + "\n", + "sliced_DA = recip_DA.sel(time=times, method='nearest')\n", + "fg = sliced_DA.plot.imshow(figsize=(18, 6), col='time', col_wrap=4, norm=plt.Normalize(cmin, cmax), cmap=cmap)\n", + "fg.cbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15)\n", + "for axes in fg.axs.flatten():\n", + " axes.set(aspect='equal')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d5442a83-2787-4166-b9ec-488eb445a573", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Saving dataset with xarray's to_zarr() method:\n", + "# # General structure below:\n", + "\n", + "# # Set where to save file and what to name it\n", + "# savePath = outPath.joinpath('testing_zarrs')\n", + "# savePath.mkdir(exist_ok=True)\n", + "# savename = 'custom_save_name.zarr'\n", + "\n", + "# # Save it\n", + "# recip_DS.to_zarr(savePath.joinpath(savename))" + ] + }, + { + "cell_type": "markdown", + "id": "ecb9f060-bb82-46a3-b4d2-eec1aea0fec8", + "metadata": { + "tags": [] + }, + "source": [ + "#### Transform data to reciprocal space: polar (caked)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9caa66b1-a127-47d1-b5c0-3bfe08a68396", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Reinitialize cartesian integrator if necessary\n", + "qpara_caked_integrator = phs.integrate.PGGeneralIntegrator(geomethod = 'ponifile',\n", + " ponifile = poniFile,\n", + " output_space = 'caked',\n", + " incident_angle = 0.12)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "5d911f29-fa11-4f3f-bff7-d1e235092dd1", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ab087a86ad7c44d3b29f3a68d2cfa986", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray (time: 100, chi: 180, qr: 1000)>\n",
+       "array([[[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "...\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]],\n",
+       "\n",
+       "       [[0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        ...,\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.],\n",
+       "        [0., 0., 0., ..., 0., 0., 0.]]], dtype=float32)\n",
+       "Coordinates:\n",
+       "  * chi      (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n",
+       "  * qr       (qr) float64 0.0001473 0.003876 0.007604 ... 3.717 3.721 3.725\n",
+       "  * time     (time) float64 0.1 0.2 0.3 0.4 0.5 0.6 ... 9.5 9.6 9.7 9.8 9.9 10.0\n",
+       "Attributes: (12/17)\n",
+       "    material:              pybtz\n",
+       "    solvent:               CBCNp5\n",
+       "    concentration:         15\n",
+       "    gap_height:            200\n",
+       "    blade_speed:           40\n",
+       "    solution_temperature:  60\n",
+       "    ...                    ...\n",
+       "    exposure_time:         0.10s\n",
+       "    scan_id:               1118329\n",
+       "    series_number:         000000\n",
+       "    detector:              maxs.tiff\n",
+       "    dims_unpacked:         ['series_number']\n",
+       "    inplane_config:        q_xy
" + ], + "text/plain": [ + "\n", + "array([[[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + "...\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]],\n", + "\n", + " [[0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " ...,\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.],\n", + " [0., 0., 0., ..., 0., 0., 0.]]], dtype=float32)\n", + "Coordinates:\n", + " * chi (chi) float64 -89.5 -88.5 -87.5 -86.5 -85.5 ... 86.5 87.5 88.5 89.5\n", + " * qr (qr) float64 0.0001473 0.003876 0.007604 ... 3.717 3.721 3.725\n", + " * time (time) float64 0.1 0.2 0.3 0.4 0.5 0.6 ... 9.5 9.6 9.7 9.8 9.9 10.0\n", + "Attributes: (12/17)\n", + " material: pybtz\n", + " solvent: CBCNp5\n", + " concentration: 15\n", + " gap_height: 200\n", + " blade_speed: 40\n", + " solution_temperature: 60\n", + " ... ...\n", + " exposure_time: 0.10s\n", + " scan_id: 1118329\n", + " series_number: 000000\n", + " detector: maxs.tiff\n", + " dims_unpacked: ['series_number']\n", + " inplane_config: q_xy" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Apply integrator to integrate the raw image stack\n", + "caked_DA = qpara_caked_integrator.integrateImageStack(raw_DA)\n", + "caked_DA" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "512b9df6-b20b-4308-a4c3-e3e818e34a30", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Facet plot of selected times\n", + "cmin = 1\n", + "cmax = 10\n", + "times = np.linspace(0.1, 10, 8)\n", + "\n", + "sliced_DA = caked_DA.sel(time=times, method='nearest')\n", + "fg = sliced_DA.plot.imshow(figsize=(18, 6), col='time', col_wrap=4, norm=plt.Normalize(cmin, cmax), cmap=cmap)\n", + "fg.cbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15)\n", + "# for axes in fg.axs.flatten():\n", + "# axes.set(aspect='equal')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5bf0c6a5-2453-40d7-b218-b153658fcf26", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# # Saving dataset with xarray's to_zarr() method:\n", + "# # General structure below:\n", + "\n", + "# # Set where to save file and what to name it\n", + "# savePath = outPath.joinpath('testing_zarrs')\n", + "# savePath.mkdir(exist_ok=True)\n", + "# savename = 'custom_save_name.zarr'\n", + "\n", + "# # Save it\n", + "# recip_DS.to_zarr(savePath.joinpath(savename))" + ] + }, + { + "cell_type": "markdown", + "id": "1eb9adc0-fe95-4113-ab8e-1ba4bda30c88", + "metadata": {}, + "source": [ + "## Not fully implemented or deprecated" + ] + }, + { + "cell_type": "markdown", + "id": "dee4856a-c267-4818-853c-93fa72e1a754", + "metadata": {}, + "source": [ + "### Yoneda peak check \n", + "This can be used as a way to verify / refine your correct beam center y position. The yoneda peak should always appear at a q value corresponding to your incident angle plus your film's critical angle. Check where it is supposed to appera and compare with experimental data, then tweak the beamcenter y position accordingly." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fd9bd8d2-5911-44f1-93f6-071cc893c9c8", + "metadata": {}, + "outputs": [], + "source": [ + "def yonda_qz(wavelength, alpha_crit, alpha_incidents):\n", + " \"\"\"Calculate the yoneda qz values given the wavelength, critical angle, and incident angle (in degrees)\"\"\"\n", + " qz_inv_meters = ((4 * np.pi) / (wavelength)) * (np.sin(np.deg2rad((alpha_incidents + alpha_crit)/2)))\n", + " qz_inv_angstroms = qz_inv_meters / 1e10\n", + " return qz_inv_angstroms\n", + "\n", + "\n", + "wavelength = 9.762535309700809e-11 # 12.7 keV\n", + "alpha_crit = 0.11 # organic film critical angle\n", + "alpha_incidents = np.array([0.08, 0.1, 0.12, 0.15]) # incident angle(s)\n", + "\n", + "yoneda_angles = alpha_incidents + alpha_crit\n", + "\n", + "qz(wavelength, alpha_crit, alpha_incidents) # expected yoneda qz positions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b1e0b436-8f7d-4e8a-b963-2df2bd836e26", + "metadata": {}, + "outputs": [], + "source": [ + "# Helper functions:\n", + "def select_attrs(data_arrays_iterable, selected_attrs_dict):\n", + " \"\"\"\n", + " Selects data arrays whose attributes match the specified values.\n", + "\n", + " Parameters:\n", + " data_arrays_iterable: Iterable of xarray.DataArray objects.\n", + " selected_attrs_dict: Dictionary where keys are attribute names and \n", + " values are the attributes' desired values.\n", + "\n", + " Returns:\n", + " List of xarray.DataArray objects that match the specified attributes.\n", + " \"\"\" \n", + " sublist = list(data_arrays_iterable)\n", + " \n", + " for attr_name, attr_values in selected_attrs_dict.items():\n", + " sublist = [da for da in sublist if da.attrs[attr_name] in attr_values]\n", + " \n", + " return sublist\n", + "\n", + "def poni_centers(poniFile, pix_size=0.000172):\n", + " \"\"\"\n", + " Returns poni center value and the corresponding pixel position. Default pixel size is 172 microns (Pilatus 1M)\n", + " \n", + " This info could be loaded better using default pyFAI methods.\n", + " \n", + " Inputs: poniFile as pathlib path object to the poni file\n", + " Outputs: ((poni1, y_center), (poni2, x_center))\n", + " \"\"\"\n", + " \n", + " with poniFile.open('r') as f:\n", + " lines = list(f.readlines())\n", + " poni1_str = lines[6]\n", + " poni2_str = lines[7]\n", + "\n", + " poni1 = float(poni1_str.split(' ')[1])\n", + " poni2 = float(poni2_str.split(' ')[1])\n", + "\n", + " y_center = poni1 / pix_size\n", + " x_center = poni2 / pix_size\n", + " \n", + " return ((poni1, y_center), (poni2, x_center))\n", + "\n", + "# poni_centers(poniFile)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "608ffaf2-b064-4e7e-825a-99f0c7038ffc", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# 2D reciprocal space cartesian plots\n", + "qxy_min = -1.1\n", + "qxy_max = 2.1\n", + "qz_min = -0.01\n", + "qz_max = 2.2\n", + "\n", + "selected_attrs_dict = {'material': ['PM6'], 'solvent': ['CBCN']}\n", + "# selected_attrs_dict = {}\n", + "\n", + "selected_DAs = select_attrs(fixed_recip_DS.data_vars.values(), selected_attrs_dict)\n", + "for DA in tqdm(selected_DAs):\n", + " # Slice data for selected q ranges (will need to rename q_xy if dimensions are differently named)\n", + " sliced_DA = DA.sel(q_xy=slice(qxy_min, qxy_max), q_z=slice(qz_min, qz_max))\n", + " \n", + " real_min = float(sliced_DA.compute().quantile(0.05))\n", + " cmin = 1 if real_min < 1 else real_min\n", + "\n", + " cmax = float(sliced_DA.compute().quantile(0.997)) \n", + " \n", + " # Plot\n", + " ax = sliced_DA.plot.imshow(cmap=cmap, norm=plt.Normalize(cmin, cmax), interpolation='antialiased', figsize=(5.5,3.3))\n", + " ax.colorbar.set_label('Intensity [arb. units]', rotation=270, labelpad=15)\n", + " # ax.axes.set(aspect='equal', title=f'Cartesian Plot: {DA.material} {DA.solvent} {DA.rpm}, {float(DA.incident_angle[2:])}° Incidence',\n", + " # xlabel='q$_{xy}$ [Å$^{-1}$]', ylabel='q$_z$ [Å$^{-1}$]')\n", + " ax.axes.set(aspect='equal', title=f'Cartesian Plot: {DA.material} {DA.solvent}, {float(DA.incident_angle[2:])}° Incidence',\n", + " xlabel='q$_{xy}$ [Å$^{-1}$]', ylabel='q$_z$ [Å$^{-1}$]')\n", + " ax.figure.set(tight_layout=True, dpi=130)\n", + " \n", + " # ax.figure.savefig(savePath.joinpath(f'{DA.material}-{DA.solvent}-{DA.rpm}_qxy{qxy_min}to{qxy_max}_qz{qz_min}to{qz_max}_{DA.incident_angle}.png'), dpi=150)\n", + " # ax.figure.savefig(savePath.joinpath(f'{DA.material}-{DA.solvent}_qxy{qxy_min}to{qxy_max}_qz{qz_min}to{qz_max}_{DA.incident_angle}.png'), dpi=150)\n", + "\n", + " plt.show()\n", + " plt.close('all')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8f3666d0-3597-4ff2-97b9-014f33b421da", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "# Yoneda peak linecut check\n", + "qxy_min = 0.22\n", + "qxy_max = 2\n", + "qz_min = -0.02\n", + "qz_max = 0.06\n", + "\n", + "selected_DAs = select_attrs(fixed_recip_DS.data_vars.values(), selected_attrs_dict)\n", + "for DA in tqdm(selected_DAs):\n", + " # Slice data for selected q ranges (will need to rename q_xy if dimensions are differently named)\n", + " sliced_DA = DA.sel(q_xy=slice(qxy_min, qxy_max), q_z=slice(qz_min, qz_max))\n", + " qz_integrated_DA = sliced_DA.sum('q_xy')\n", + " \n", + " # Plot\n", + " qz_integrated_DA.plot.line(label=DA.incident_angle)\n", + " \n", + "plt.legend()\n", + "plt.grid(visible=True, which='major', axis='x')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "b0c6fde7-bfff-49ad-8e33-9865e9a480ad", + "metadata": {}, + "source": [ + "### phs.CMSGIWAXS.loadSeries()\n", + "If it's easier to sort/filter/organize files outside of the loadFileSeries filter arguments. The option to enter a list of filepaths into loadFileSeries will be implemented soon.\n", + "\n", + "If integrating time series data, the legacy loadSeries method will accept these iterables for loading the data stack. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "312f225f-38f0-4b47-badb-a6b546e89f73", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "raw_DA = series_loader.loadSeries(sorted(exp0p1_set))\n", + "display(raw_DA)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "nrss", + "language": "python", + "name": "nrss" + }, + "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.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/versioneer.py b/versioneer.py index 97130070..1e3753e6 100644 --- a/versioneer.py +++ b/versioneer.py @@ -1,5 +1,5 @@ -# Version: 0.20 +# Version: 0.29 """The Versioneer - like a rocketeer, but for versions. @@ -9,12 +9,12 @@ * like a rocketeer, but for versions! * https://github.com/python-versioneer/python-versioneer * Brian Warner -* License: Public Domain -* Compatible with: Python 3.6, 3.7, 3.8, 3.9 and pypy3 +* License: Public Domain (Unlicense) +* Compatible with: Python 3.7, 3.8, 3.9, 3.10, 3.11 and pypy3 * [![Latest Version][pypi-image]][pypi-url] * [![Build Status][travis-image]][travis-url] -This is a tool for managing a recorded version number in distutils-based +This is a tool for managing a recorded version number in setuptools-based python projects. The goal is to remove the tedious and error-prone "update the embedded version string" step from your release process. Making a new release should be as easy as recording a new tag in your version-control @@ -23,10 +23,38 @@ ## Quick Install +Versioneer provides two installation modes. The "classic" vendored mode installs +a copy of versioneer into your repository. The experimental build-time dependency mode +is intended to allow you to skip this step and simplify the process of upgrading. + +### Vendored mode + +* `pip install versioneer` to somewhere in your $PATH + * A [conda-forge recipe](https://github.com/conda-forge/versioneer-feedstock) is + available, so you can also use `conda install -c conda-forge versioneer` +* add a `[tool.versioneer]` section to your `pyproject.toml` or a + `[versioneer]` section to your `setup.cfg` (see [Install](INSTALL.md)) + * Note that you will need to add `tomli; python_version < "3.11"` to your + build-time dependencies if you use `pyproject.toml` +* run `versioneer install --vendor` in your source tree, commit the results +* verify version information with `python setup.py version` + +### Build-time dependency mode + * `pip install versioneer` to somewhere in your $PATH -* add a `[versioneer]` section to your setup.cfg (see [Install](INSTALL.md)) -* run `versioneer install` in your source tree, commit the results -* Verify version information with `python setup.py version` + * A [conda-forge recipe](https://github.com/conda-forge/versioneer-feedstock) is + available, so you can also use `conda install -c conda-forge versioneer` +* add a `[tool.versioneer]` section to your `pyproject.toml` or a + `[versioneer]` section to your `setup.cfg` (see [Install](INSTALL.md)) +* add `versioneer` (with `[toml]` extra, if configuring in `pyproject.toml`) + to the `requires` key of the `build-system` table in `pyproject.toml`: + ```toml + [build-system] + requires = ["setuptools", "versioneer[toml]"] + build-backend = "setuptools.build_meta" + ``` +* run `versioneer install --no-vendor` in your source tree, commit the results +* verify version information with `python setup.py version` ## Version Identifiers @@ -231,9 +259,10 @@ To upgrade your project to a new release of Versioneer, do the following: * install the new Versioneer (`pip install -U versioneer` or equivalent) -* edit `setup.cfg`, if necessary, to include any new configuration settings - indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details. -* re-run `versioneer install` in your source tree, to replace +* edit `setup.cfg` and `pyproject.toml`, if necessary, + to include any new configuration settings indicated by the release notes. + See [UPGRADING](./UPGRADING.md) for details. +* re-run `versioneer install --[no-]vendor` in your source tree, to replace `SRC/_version.py` * commit any changed files @@ -263,9 +292,8 @@ To make Versioneer easier to embed, all its code is dedicated to the public domain. The `_version.py` that it creates is also in the public domain. -Specifically, both are released under the Creative Commons "Public Domain -Dedication" license (CC0-1.0), as described in -https://creativecommons.org/publicdomain/zero/1.0/ . +Specifically, both are released under the "Unlicense", as described in +https://unlicense.org/. [pypi-image]: https://img.shields.io/pypi/v/versioneer.svg [pypi-url]: https://pypi.python.org/pypi/versioneer/ @@ -274,6 +302,11 @@ [travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer """ +# pylint:disable=invalid-name,import-outside-toplevel,missing-function-docstring +# pylint:disable=missing-class-docstring,too-many-branches,too-many-statements +# pylint:disable=raise-missing-from,too-many-lines,too-many-locals,import-error +# pylint:disable=too-few-public-methods,redefined-outer-name,consider-using-with +# pylint:disable=attribute-defined-outside-init,too-many-arguments import configparser import errno @@ -282,13 +315,34 @@ import re import subprocess import sys +from pathlib import Path +from typing import Any, Callable, cast, Dict, List, Optional, Tuple, Union +from typing import NoReturn +import functools + +have_tomllib = True +if sys.version_info >= (3, 11): + import tomllib +else: + try: + import tomli as tomllib + except ImportError: + have_tomllib = False -class VersioneerConfig: # pylint: disable=too-few-public-methods # noqa +class VersioneerConfig: """Container for Versioneer configuration parameters.""" + VCS: str + style: str + tag_prefix: str + versionfile_source: str + versionfile_build: Optional[str] + parentdir_prefix: Optional[str] + verbose: Optional[bool] -def get_root(): + +def get_root() -> str: """Get the project root directory. We require that all commands are run from the project root, i.e. the @@ -296,13 +350,23 @@ def get_root(): """ root = os.path.realpath(os.path.abspath(os.getcwd())) setup_py = os.path.join(root, "setup.py") + pyproject_toml = os.path.join(root, "pyproject.toml") versioneer_py = os.path.join(root, "versioneer.py") - if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): + if not ( + os.path.exists(setup_py) + or os.path.exists(pyproject_toml) + or os.path.exists(versioneer_py) + ): # allow 'python path/to/setup.py COMMAND' root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0]))) setup_py = os.path.join(root, "setup.py") + pyproject_toml = os.path.join(root, "pyproject.toml") versioneer_py = os.path.join(root, "versioneer.py") - if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): + if not ( + os.path.exists(setup_py) + or os.path.exists(pyproject_toml) + or os.path.exists(versioneer_py) + ): err = ("Versioneer was unable to run the project root directory. " "Versioneer requires setup.py to be executed from " "its immediate directory (like 'python setup.py COMMAND'), " @@ -319,7 +383,7 @@ def get_root(): my_path = os.path.realpath(os.path.abspath(__file__)) me_dir = os.path.normcase(os.path.splitext(my_path)[0]) vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) - if me_dir != vsr_dir: + if me_dir != vsr_dir and "VERSIONEER_PEP518" not in globals(): print("Warning: build in %s is using versioneer.py from %s" % (os.path.dirname(my_path), versioneer_py)) except NameError: @@ -327,32 +391,51 @@ def get_root(): return root -def get_config_from_root(root): +def get_config_from_root(root: str) -> VersioneerConfig: """Read the project setup.cfg file to determine Versioneer config.""" - # This might raise EnvironmentError (if setup.cfg is missing), or + # This might raise OSError (if setup.cfg is missing), or # configparser.NoSectionError (if it lacks a [versioneer] section), or # configparser.NoOptionError (if it lacks "VCS="). See the docstring at # the top of versioneer.py for instructions on writing your setup.cfg . - setup_cfg = os.path.join(root, "setup.cfg") - parser = configparser.ConfigParser() - with open(setup_cfg, "r") as cfg_file: - parser.read_file(cfg_file) - VCS = parser.get("versioneer", "VCS") # mandatory - - # Dict-like interface for non-mandatory entries - section = parser["versioneer"] + root_pth = Path(root) + pyproject_toml = root_pth / "pyproject.toml" + setup_cfg = root_pth / "setup.cfg" + section: Union[Dict[str, Any], configparser.SectionProxy, None] = None + if pyproject_toml.exists() and have_tomllib: + try: + with open(pyproject_toml, 'rb') as fobj: + pp = tomllib.load(fobj) + section = pp['tool']['versioneer'] + except (tomllib.TOMLDecodeError, KeyError) as e: + print(f"Failed to load config from {pyproject_toml}: {e}") + print("Try to load it from setup.cfg") + if not section: + parser = configparser.ConfigParser() + with open(setup_cfg) as cfg_file: + parser.read_file(cfg_file) + parser.get("versioneer", "VCS") # raise error if missing + + section = parser["versioneer"] + + # `cast`` really shouldn't be used, but its simplest for the + # common VersioneerConfig users at the moment. We verify against + # `None` values elsewhere where it matters - # pylint:disable=attribute-defined-outside-init # noqa cfg = VersioneerConfig() - cfg.VCS = VCS + cfg.VCS = section['VCS'] cfg.style = section.get("style", "") - cfg.versionfile_source = section.get("versionfile_source") + cfg.versionfile_source = cast(str, section.get("versionfile_source")) cfg.versionfile_build = section.get("versionfile_build") - cfg.tag_prefix = section.get("tag_prefix") - if cfg.tag_prefix in ("''", '""'): + cfg.tag_prefix = cast(str, section.get("tag_prefix")) + if cfg.tag_prefix in ("''", '""', None): cfg.tag_prefix = "" cfg.parentdir_prefix = section.get("parentdir_prefix") - cfg.verbose = section.get("verbose") + if isinstance(section, configparser.SectionProxy): + # Make sure configparser translates to bool + cfg.verbose = section.getboolean("verbose") + else: + cfg.verbose = section.get("verbose") + return cfg @@ -361,25 +444,38 @@ class NotThisMethod(Exception): # these dictionaries contain VCS-specific tools -LONG_VERSION_PY = {} -HANDLERS = {} +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} -def register_vcs_handler(vcs, method): # decorator +def register_vcs_handler(vcs: str, method: str) -> Callable: # decorator """Create decorator to mark a method as the handler of a VCS.""" - def decorate(f): + def decorate(f: Callable) -> Callable: """Store f in HANDLERS[vcs][method].""" HANDLERS.setdefault(vcs, {})[method] = f return f return decorate -# pylint:disable=too-many-arguments,consider-using-with # noqa -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): +def run_command( + commands: List[str], + args: List[str], + cwd: Optional[str] = None, + verbose: bool = False, + hide_stderr: bool = False, + env: Optional[Dict[str, str]] = None, +) -> Tuple[Optional[str], Optional[int]]: """Call the given command(s).""" assert isinstance(commands, list) process = None + + popen_kwargs: Dict[str, Any] = {} + if sys.platform == "win32": + # This hides the console window if pythonw.exe is used + startupinfo = subprocess.STARTUPINFO() + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + popen_kwargs["startupinfo"] = startupinfo + for command in commands: try: dispcmd = str([command] + args) @@ -387,10 +483,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, process = subprocess.Popen([command] + args, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr - else None)) + else None), **popen_kwargs) break - except EnvironmentError: - e = sys.exc_info()[1] + except OSError as e: if e.errno == errno.ENOENT: continue if verbose: @@ -417,8 +512,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, # directories (produced by setup.py build) will contain a much shorter file # that just contains the computed version number. -# This file is released into the public domain. Generated by -# versioneer-0.20 (https://github.com/python-versioneer/python-versioneer) +# This file is released into the public domain. +# Generated by versioneer-0.29 +# https://github.com/python-versioneer/python-versioneer """Git implementation of _version.py.""" @@ -427,9 +523,11 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, import re import subprocess import sys +from typing import Any, Callable, Dict, List, Optional, Tuple +import functools -def get_keywords(): +def get_keywords() -> Dict[str, str]: """Get the keywords needed to look up the version information.""" # these strings will be replaced by git during git-archive. # setup.py/versioneer.py will grep for the variable names, so they must @@ -442,11 +540,18 @@ def get_keywords(): return keywords -class VersioneerConfig: # pylint: disable=too-few-public-methods +class VersioneerConfig: """Container for Versioneer configuration parameters.""" + VCS: str + style: str + tag_prefix: str + parentdir_prefix: str + versionfile_source: str + verbose: bool + -def get_config(): +def get_config() -> VersioneerConfig: """Create, populate and return the VersioneerConfig() object.""" # these strings are filled in when 'setup.py versioneer' creates # _version.py @@ -464,13 +569,13 @@ class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" -LONG_VERSION_PY = {} -HANDLERS = {} +LONG_VERSION_PY: Dict[str, str] = {} +HANDLERS: Dict[str, Dict[str, Callable]] = {} -def register_vcs_handler(vcs, method): # decorator +def register_vcs_handler(vcs: str, method: str) -> Callable: # decorator """Create decorator to mark a method as the handler of a VCS.""" - def decorate(f): + def decorate(f: Callable) -> Callable: """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} @@ -479,12 +584,25 @@ def decorate(f): return decorate -# pylint:disable=too-many-arguments,consider-using-with # noqa -def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, - env=None): +def run_command( + commands: List[str], + args: List[str], + cwd: Optional[str] = None, + verbose: bool = False, + hide_stderr: bool = False, + env: Optional[Dict[str, str]] = None, +) -> Tuple[Optional[str], Optional[int]]: """Call the given command(s).""" assert isinstance(commands, list) process = None + + popen_kwargs: Dict[str, Any] = {} + if sys.platform == "win32": + # This hides the console window if pythonw.exe is used + startupinfo = subprocess.STARTUPINFO() + startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW + popen_kwargs["startupinfo"] = startupinfo + for command in commands: try: dispcmd = str([command] + args) @@ -492,10 +610,9 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, process = subprocess.Popen([command] + args, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr - else None)) + else None), **popen_kwargs) break - except EnvironmentError: - e = sys.exc_info()[1] + except OSError as e: if e.errno == errno.ENOENT: continue if verbose: @@ -515,7 +632,11 @@ def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, return stdout, process.returncode -def versions_from_parentdir(parentdir_prefix, root, verbose): +def versions_from_parentdir( + parentdir_prefix: str, + root: str, + verbose: bool, +) -> Dict[str, Any]: """Try to determine the version from the parent directory name. Source tarballs conventionally unpack into a directory that includes both @@ -540,13 +661,13 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): @register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): +def git_get_keywords(versionfile_abs: str) -> Dict[str, str]: """Extract version information from the given file.""" # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. - keywords = {} + keywords: Dict[str, str] = {} try: with open(versionfile_abs, "r") as fobj: for line in fobj: @@ -562,13 +683,17 @@ def git_get_keywords(versionfile_abs): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["date"] = mo.group(1) - except EnvironmentError: + except OSError: pass return keywords @register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): +def git_versions_from_keywords( + keywords: Dict[str, str], + tag_prefix: str, + verbose: bool, +) -> Dict[str, Any]: """Get version information from git keywords.""" if "refnames" not in keywords: raise NotThisMethod("Short version file found") @@ -632,7 +757,12 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): @register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): +def git_pieces_from_vcs( + tag_prefix: str, + root: str, + verbose: bool, + runner: Callable = run_command +) -> Dict[str, Any]: """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* @@ -643,8 +773,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] + # GIT_DIR can interfere with correct operation of Versioneer. + # It may be intended to be passed to the Versioneer-versioned project, + # but that should not change where we get our version from. + env = os.environ.copy() + env.pop("GIT_DIR", None) + runner = functools.partial(runner, env=env) + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) + hide_stderr=not verbose) if rc != 0: if verbose: print("Directory %%s not under git control" %% root) @@ -652,10 +789,10 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%%s*" %% tag_prefix], - cwd=root) + describe_out, rc = runner(GITS, [ + "describe", "--tags", "--dirty", "--always", "--long", + "--match", f"{tag_prefix}[[:digit:]]*" + ], cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -665,7 +802,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() - pieces = {} + pieces: Dict[str, Any] = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None @@ -719,7 +856,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: - # unparseable. Maybe git-describe is misbehaving? + # unparsable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%%s'" %% describe_out) return pieces @@ -744,8 +881,8 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) - pieces["distance"] = int(count_out) # total number of commits + out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) + pieces["distance"] = len(out.split()) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() date = runner(GITS, ["show", "-s", "--format=%%ci", "HEAD"], cwd=root)[0].strip() @@ -757,14 +894,14 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): return pieces -def plus_or_dot(pieces): +def plus_or_dot(pieces: Dict[str, Any]) -> str: """Return a + if we don't already have one, else return a .""" if "+" in pieces.get("closest-tag", ""): return "." return "+" -def render_pep440(pieces): +def render_pep440(pieces: Dict[str, Any]) -> str: """Build up version string, with post-release "local version identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you @@ -789,7 +926,7 @@ def render_pep440(pieces): return rendered -def render_pep440_branch(pieces): +def render_pep440_branch(pieces: Dict[str, Any]) -> str: """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . The ".dev0" means not master branch. Note that .dev0 sorts backwards @@ -819,23 +956,41 @@ def render_pep440_branch(pieces): return rendered -def render_pep440_pre(pieces): - """TAG[.post0.devDISTANCE] -- No -dirty. +def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]: + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces: Dict[str, Any]) -> str: + """TAG[.postN.devDISTANCE] -- No -dirty. Exceptions: 1: no tags. 0.post0.devDISTANCE """ if pieces["closest-tag"]: - rendered = pieces["closest-tag"] if pieces["distance"]: - rendered += ".post0.dev%%d" %% pieces["distance"] + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%%d.dev%%d" %% (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%%d" %% (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] else: # exception #1 rendered = "0.post0.dev%%d" %% pieces["distance"] return rendered -def render_pep440_post(pieces): +def render_pep440_post(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that .dev0 sorts backwards @@ -862,7 +1017,7 @@ def render_pep440_post(pieces): return rendered -def render_pep440_post_branch(pieces): +def render_pep440_post_branch(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . The ".dev0" means not master branch. @@ -891,7 +1046,7 @@ def render_pep440_post_branch(pieces): return rendered -def render_pep440_old(pieces): +def render_pep440_old(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. @@ -913,7 +1068,7 @@ def render_pep440_old(pieces): return rendered -def render_git_describe(pieces): +def render_git_describe(pieces: Dict[str, Any]) -> str: """TAG[-DISTANCE-gHEX][-dirty]. Like 'git describe --tags --dirty --always'. @@ -933,7 +1088,7 @@ def render_git_describe(pieces): return rendered -def render_git_describe_long(pieces): +def render_git_describe_long(pieces: Dict[str, Any]) -> str: """TAG-DISTANCE-gHEX[-dirty]. Like 'git describe --tags --dirty --always -long'. @@ -953,7 +1108,7 @@ def render_git_describe_long(pieces): return rendered -def render(pieces, style): +def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]: """Render the given version pieces into the requested style.""" if pieces["error"]: return {"version": "unknown", @@ -989,7 +1144,7 @@ def render(pieces, style): "date": pieces.get("date")} -def get_versions(): +def get_versions() -> Dict[str, Any]: """Get version information or return default if unable to do so.""" # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have # __file__, we can work backwards from there to the root. Some @@ -1037,13 +1192,13 @@ def get_versions(): @register_vcs_handler("git", "get_keywords") -def git_get_keywords(versionfile_abs): +def git_get_keywords(versionfile_abs: str) -> Dict[str, str]: """Extract version information from the given file.""" # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. - keywords = {} + keywords: Dict[str, str] = {} try: with open(versionfile_abs, "r") as fobj: for line in fobj: @@ -1059,13 +1214,17 @@ def git_get_keywords(versionfile_abs): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["date"] = mo.group(1) - except EnvironmentError: + except OSError: pass return keywords @register_vcs_handler("git", "keywords") -def git_versions_from_keywords(keywords, tag_prefix, verbose): +def git_versions_from_keywords( + keywords: Dict[str, str], + tag_prefix: str, + verbose: bool, +) -> Dict[str, Any]: """Get version information from git keywords.""" if "refnames" not in keywords: raise NotThisMethod("Short version file found") @@ -1129,7 +1288,12 @@ def git_versions_from_keywords(keywords, tag_prefix, verbose): @register_vcs_handler("git", "pieces_from_vcs") -def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): +def git_pieces_from_vcs( + tag_prefix: str, + root: str, + verbose: bool, + runner: Callable = run_command +) -> Dict[str, Any]: """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* @@ -1140,8 +1304,15 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] + # GIT_DIR can interfere with correct operation of Versioneer. + # It may be intended to be passed to the Versioneer-versioned project, + # but that should not change where we get our version from. + env = os.environ.copy() + env.pop("GIT_DIR", None) + runner = functools.partial(runner, env=env) + _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, - hide_stderr=True) + hide_stderr=not verbose) if rc != 0: if verbose: print("Directory %s not under git control" % root) @@ -1149,10 +1320,10 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) - describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty", - "--always", "--long", - "--match", "%s*" % tag_prefix], - cwd=root) + describe_out, rc = runner(GITS, [ + "describe", "--tags", "--dirty", "--always", "--long", + "--match", f"{tag_prefix}[[:digit:]]*" + ], cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") @@ -1162,7 +1333,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() - pieces = {} + pieces: Dict[str, Any] = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None @@ -1216,7 +1387,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: - # unparseable. Maybe git-describe is misbehaving? + # unparsable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%s'" % describe_out) return pieces @@ -1241,8 +1412,8 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): else: # HEX: no tags pieces["closest-tag"] = None - count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) - pieces["distance"] = int(count_out) # total number of commits + out, rc = runner(GITS, ["rev-list", "HEAD", "--left-right"], cwd=root) + pieces["distance"] = len(out.split()) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() @@ -1254,7 +1425,7 @@ def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): return pieces -def do_vcs_install(manifest_in, versionfile_source, ipy): +def do_vcs_install(versionfile_source: str, ipy: Optional[str]) -> None: """Git-specific installation logic for Versioneer. For Git, this means creating/changing .gitattributes to mark _version.py @@ -1263,17 +1434,18 @@ def do_vcs_install(manifest_in, versionfile_source, ipy): GITS = ["git"] if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] - files = [manifest_in, versionfile_source] + files = [versionfile_source] if ipy: files.append(ipy) - try: - my_path = __file__ - if my_path.endswith(".pyc") or my_path.endswith(".pyo"): - my_path = os.path.splitext(my_path)[0] + ".py" - versioneer_file = os.path.relpath(my_path) - except NameError: - versioneer_file = "versioneer.py" - files.append(versioneer_file) + if "VERSIONEER_PEP518" not in globals(): + try: + my_path = __file__ + if my_path.endswith((".pyc", ".pyo")): + my_path = os.path.splitext(my_path)[0] + ".py" + versioneer_file = os.path.relpath(my_path) + except NameError: + versioneer_file = "versioneer.py" + files.append(versioneer_file) present = False try: with open(".gitattributes", "r") as fobj: @@ -1282,7 +1454,7 @@ def do_vcs_install(manifest_in, versionfile_source, ipy): if "export-subst" in line.strip().split()[1:]: present = True break - except EnvironmentError: + except OSError: pass if not present: with open(".gitattributes", "a+") as fobj: @@ -1291,7 +1463,11 @@ def do_vcs_install(manifest_in, versionfile_source, ipy): run_command(GITS, ["add", "--"] + files) -def versions_from_parentdir(parentdir_prefix, root, verbose): +def versions_from_parentdir( + parentdir_prefix: str, + root: str, + verbose: bool, +) -> Dict[str, Any]: """Try to determine the version from the parent directory name. Source tarballs conventionally unpack into a directory that includes both @@ -1316,7 +1492,7 @@ def versions_from_parentdir(parentdir_prefix, root, verbose): SHORT_VERSION_PY = """ -# This file was generated by 'versioneer.py' (0.20) from +# This file was generated by 'versioneer.py' (0.29) from # revision-control system data, or from the parent directory name of an # unpacked source archive. Distribution tarballs contain a pre-generated copy # of this file. @@ -1333,12 +1509,12 @@ def get_versions(): """ -def versions_from_file(filename): +def versions_from_file(filename: str) -> Dict[str, Any]: """Try to determine the version from _version.py if present.""" try: with open(filename) as f: contents = f.read() - except EnvironmentError: + except OSError: raise NotThisMethod("unable to read _version.py") mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", contents, re.M | re.S) @@ -1350,9 +1526,8 @@ def versions_from_file(filename): return json.loads(mo.group(1)) -def write_to_version_file(filename, versions): +def write_to_version_file(filename: str, versions: Dict[str, Any]) -> None: """Write the given version number to the given _version.py file.""" - os.unlink(filename) contents = json.dumps(versions, sort_keys=True, indent=1, separators=(",", ": ")) with open(filename, "w") as f: @@ -1361,14 +1536,14 @@ def write_to_version_file(filename, versions): print("set %s to '%s'" % (filename, versions["version"])) -def plus_or_dot(pieces): +def plus_or_dot(pieces: Dict[str, Any]) -> str: """Return a + if we don't already have one, else return a .""" if "+" in pieces.get("closest-tag", ""): return "." return "+" -def render_pep440(pieces): +def render_pep440(pieces: Dict[str, Any]) -> str: """Build up version string, with post-release "local version identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you @@ -1393,7 +1568,7 @@ def render_pep440(pieces): return rendered -def render_pep440_branch(pieces): +def render_pep440_branch(pieces: Dict[str, Any]) -> str: """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . The ".dev0" means not master branch. Note that .dev0 sorts backwards @@ -1423,23 +1598,41 @@ def render_pep440_branch(pieces): return rendered -def render_pep440_pre(pieces): - """TAG[.post0.devDISTANCE] -- No -dirty. +def pep440_split_post(ver: str) -> Tuple[str, Optional[int]]: + """Split pep440 version string at the post-release segment. + + Returns the release segments before the post-release and the + post-release version number (or -1 if no post-release segment is present). + """ + vc = str.split(ver, ".post") + return vc[0], int(vc[1] or 0) if len(vc) == 2 else None + + +def render_pep440_pre(pieces: Dict[str, Any]) -> str: + """TAG[.postN.devDISTANCE] -- No -dirty. Exceptions: 1: no tags. 0.post0.devDISTANCE """ if pieces["closest-tag"]: - rendered = pieces["closest-tag"] if pieces["distance"]: - rendered += ".post0.dev%d" % pieces["distance"] + # update the post release segment + tag_version, post_version = pep440_split_post(pieces["closest-tag"]) + rendered = tag_version + if post_version is not None: + rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) + else: + rendered += ".post0.dev%d" % (pieces["distance"]) + else: + # no commits, use the tag as the version + rendered = pieces["closest-tag"] else: # exception #1 rendered = "0.post0.dev%d" % pieces["distance"] return rendered -def render_pep440_post(pieces): +def render_pep440_post(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that .dev0 sorts backwards @@ -1466,7 +1659,7 @@ def render_pep440_post(pieces): return rendered -def render_pep440_post_branch(pieces): +def render_pep440_post_branch(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . The ".dev0" means not master branch. @@ -1495,7 +1688,7 @@ def render_pep440_post_branch(pieces): return rendered -def render_pep440_old(pieces): +def render_pep440_old(pieces: Dict[str, Any]) -> str: """TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. @@ -1517,7 +1710,7 @@ def render_pep440_old(pieces): return rendered -def render_git_describe(pieces): +def render_git_describe(pieces: Dict[str, Any]) -> str: """TAG[-DISTANCE-gHEX][-dirty]. Like 'git describe --tags --dirty --always'. @@ -1537,7 +1730,7 @@ def render_git_describe(pieces): return rendered -def render_git_describe_long(pieces): +def render_git_describe_long(pieces: Dict[str, Any]) -> str: """TAG-DISTANCE-gHEX[-dirty]. Like 'git describe --tags --dirty --always -long'. @@ -1557,7 +1750,7 @@ def render_git_describe_long(pieces): return rendered -def render(pieces, style): +def render(pieces: Dict[str, Any], style: str) -> Dict[str, Any]: """Render the given version pieces into the requested style.""" if pieces["error"]: return {"version": "unknown", @@ -1597,7 +1790,7 @@ class VersioneerBadRootError(Exception): """The project root directory is unknown or missing key files.""" -def get_versions(verbose=False): +def get_versions(verbose: bool = False) -> Dict[str, Any]: """Get the project version from whatever source is available. Returns dict with two keys: 'version' and 'full'. @@ -1612,7 +1805,7 @@ def get_versions(verbose=False): assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg" handlers = HANDLERS.get(cfg.VCS) assert handlers, "unrecognized VCS '%s'" % cfg.VCS - verbose = verbose or cfg.verbose + verbose = verbose or bool(cfg.verbose) # `bool()` used to avoid `None` assert cfg.versionfile_source is not None, \ "please set versioneer.versionfile_source" assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" @@ -1673,13 +1866,13 @@ def get_versions(verbose=False): "date": None} -def get_version(): +def get_version() -> str: """Get the short version string for this project.""" return get_versions()["version"] -def get_cmdclass(cmdclass=None): - """Get the custom setuptools/distutils subclasses used by Versioneer. +def get_cmdclass(cmdclass: Optional[Dict[str, Any]] = None): + """Get the custom setuptools subclasses used by Versioneer. If the package uses a different cmdclass (e.g. one from numpy), it should be provide as an argument. @@ -1701,21 +1894,21 @@ def get_cmdclass(cmdclass=None): cmds = {} if cmdclass is None else cmdclass.copy() - # we add "version" to both distutils and setuptools - from distutils.core import Command + # we add "version" to setuptools + from setuptools import Command class cmd_version(Command): description = "report generated version string" - user_options = [] - boolean_options = [] + user_options: List[Tuple[str, str, str]] = [] + boolean_options: List[str] = [] - def initialize_options(self): + def initialize_options(self) -> None: pass - def finalize_options(self): + def finalize_options(self) -> None: pass - def run(self): + def run(self) -> None: vers = get_versions(verbose=True) print("Version: %s" % vers["version"]) print(" full-revisionid: %s" % vers.get("full-revisionid")) @@ -1725,7 +1918,7 @@ def run(self): print(" error: %s" % vers["error"]) cmds["version"] = cmd_version - # we override "build_py" in both distutils and setuptools + # we override "build_py" in setuptools # # most invocation pathways end up running build_py: # distutils/build -> build_py @@ -1740,20 +1933,25 @@ def run(self): # then does setup.py bdist_wheel, or sometimes setup.py install # setup.py egg_info -> ? + # pip install -e . and setuptool/editable_wheel will invoke build_py + # but the build_py command is not expected to copy any files. + # we override different "build_py" commands for both environments if 'build_py' in cmds: - _build_py = cmds['build_py'] - elif "setuptools" in sys.modules: - from setuptools.command.build_py import build_py as _build_py + _build_py: Any = cmds['build_py'] else: - from distutils.command.build_py import build_py as _build_py + from setuptools.command.build_py import build_py as _build_py class cmd_build_py(_build_py): - def run(self): + def run(self) -> None: root = get_root() cfg = get_config_from_root(root) versions = get_versions() _build_py.run(self) + if getattr(self, "editable_mode", False): + # During editable installs `.py` and data files are + # not copied to build_lib + return # now locate _version.py in the new build/ directory and replace # it with an updated value if cfg.versionfile_build: @@ -1764,14 +1962,12 @@ def run(self): cmds["build_py"] = cmd_build_py if 'build_ext' in cmds: - _build_ext = cmds['build_ext'] - elif "setuptools" in sys.modules: - from setuptools.command.build_ext import build_ext as _build_ext + _build_ext: Any = cmds['build_ext'] else: - from distutils.command.build_ext import build_ext as _build_ext + from setuptools.command.build_ext import build_ext as _build_ext class cmd_build_ext(_build_ext): - def run(self): + def run(self) -> None: root = get_root() cfg = get_config_from_root(root) versions = get_versions() @@ -1784,14 +1980,21 @@ def run(self): return # now locate _version.py in the new build/ directory and replace # it with an updated value + if not cfg.versionfile_build: + return target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build) + if not os.path.exists(target_versionfile): + print(f"Warning: {target_versionfile} does not exist, skipping " + "version update. This can happen if you are running build_ext " + "without first running build_py.") + return print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) cmds["build_ext"] = cmd_build_ext if "cx_Freeze" in sys.modules: # cx_freeze enabled? - from cx_Freeze.dist import build_exe as _build_exe + from cx_Freeze.dist import build_exe as _build_exe # type: ignore # nczeczulin reports that py2exe won't like the pep440-style string # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. # setup(console=[{ @@ -1800,7 +2003,7 @@ def run(self): # ... class cmd_build_exe(_build_exe): - def run(self): + def run(self) -> None: root = get_root() cfg = get_config_from_root(root) versions = get_versions() @@ -1823,10 +2026,13 @@ def run(self): del cmds["build_py"] if 'py2exe' in sys.modules: # py2exe enabled? - from py2exe.distutils_buildexe import py2exe as _py2exe + try: + from py2exe.setuptools_buildexe import py2exe as _py2exe # type: ignore + except ImportError: + from py2exe.distutils_buildexe import py2exe as _py2exe # type: ignore class cmd_py2exe(_py2exe): - def run(self): + def run(self) -> None: root = get_root() cfg = get_config_from_root(root) versions = get_versions() @@ -1847,25 +2053,59 @@ def run(self): }) cmds["py2exe"] = cmd_py2exe + # sdist farms its file list building out to egg_info + if 'egg_info' in cmds: + _egg_info: Any = cmds['egg_info'] + else: + from setuptools.command.egg_info import egg_info as _egg_info + + class cmd_egg_info(_egg_info): + def find_sources(self) -> None: + # egg_info.find_sources builds the manifest list and writes it + # in one shot + super().find_sources() + + # Modify the filelist and normalize it + root = get_root() + cfg = get_config_from_root(root) + self.filelist.append('versioneer.py') + if cfg.versionfile_source: + # There are rare cases where versionfile_source might not be + # included by default, so we must be explicit + self.filelist.append(cfg.versionfile_source) + self.filelist.sort() + self.filelist.remove_duplicates() + + # The write method is hidden in the manifest_maker instance that + # generated the filelist and was thrown away + # We will instead replicate their final normalization (to unicode, + # and POSIX-style paths) + from setuptools import unicode_utils + normalized = [unicode_utils.filesys_decode(f).replace(os.sep, '/') + for f in self.filelist.files] + + manifest_filename = os.path.join(self.egg_info, 'SOURCES.txt') + with open(manifest_filename, 'w') as fobj: + fobj.write('\n'.join(normalized)) + + cmds['egg_info'] = cmd_egg_info + # we override different "sdist" commands for both environments if 'sdist' in cmds: - _sdist = cmds['sdist'] - elif "setuptools" in sys.modules: - from setuptools.command.sdist import sdist as _sdist + _sdist: Any = cmds['sdist'] else: - from distutils.command.sdist import sdist as _sdist + from setuptools.command.sdist import sdist as _sdist class cmd_sdist(_sdist): - def run(self): + def run(self) -> None: versions = get_versions() - # pylint:disable=attribute-defined-outside-init # noqa self._versioneer_generated_versions = versions # unless we update this, the command will keep using the old # version self.distribution.metadata.version = versions["version"] return _sdist.run(self) - def make_release_tree(self, base_dir, files): + def make_release_tree(self, base_dir: str, files: List[str]) -> None: root = get_root() cfg = get_config_from_root(root) _sdist.make_release_tree(self, base_dir, files) @@ -1930,14 +2170,14 @@ def make_release_tree(self, base_dir, files): """ -def do_setup(): +def do_setup() -> int: """Do main VCS-independent setup function for installing Versioneer.""" root = get_root() try: cfg = get_config_from_root(root) - except (EnvironmentError, configparser.NoSectionError, + except (OSError, configparser.NoSectionError, configparser.NoOptionError) as e: - if isinstance(e, (EnvironmentError, configparser.NoSectionError)): + if isinstance(e, (OSError, configparser.NoSectionError)): print("Adding sample versioneer config to setup.cfg", file=sys.stderr) with open(os.path.join(root, "setup.cfg"), "a") as f: @@ -1957,11 +2197,12 @@ def do_setup(): ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") + maybe_ipy: Optional[str] = ipy if os.path.exists(ipy): try: with open(ipy, "r") as f: old = f.read() - except EnvironmentError: + except OSError: old = "" module = os.path.splitext(os.path.basename(cfg.versionfile_source))[0] snippet = INIT_PY_SNIPPET.format(module) @@ -1977,48 +2218,16 @@ def do_setup(): print(" %s unmodified" % ipy) else: print(" %s doesn't exist, ok" % ipy) - ipy = None - - # Make sure both the top-level "versioneer.py" and versionfile_source - # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so - # they'll be copied into source distributions. Pip won't be able to - # install the package without this. - manifest_in = os.path.join(root, "MANIFEST.in") - simple_includes = set() - try: - with open(manifest_in, "r") as f: - for line in f: - if line.startswith("include "): - for include in line.split()[1:]: - simple_includes.add(include) - except EnvironmentError: - pass - # That doesn't cover everything MANIFEST.in can do - # (http://docs.python.org/2/distutils/sourcedist.html#commands), so - # it might give some false negatives. Appending redundant 'include' - # lines is safe, though. - if "versioneer.py" not in simple_includes: - print(" appending 'versioneer.py' to MANIFEST.in") - with open(manifest_in, "a") as f: - f.write("include versioneer.py\n") - else: - print(" 'versioneer.py' already in MANIFEST.in") - if cfg.versionfile_source not in simple_includes: - print(" appending versionfile_source ('%s') to MANIFEST.in" % - cfg.versionfile_source) - with open(manifest_in, "a") as f: - f.write("include %s\n" % cfg.versionfile_source) - else: - print(" versionfile_source already in MANIFEST.in") + maybe_ipy = None # Make VCS-specific changes. For git, this means creating/changing # .gitattributes to mark _version.py for export-subst keyword # substitution. - do_vcs_install(manifest_in, cfg.versionfile_source, ipy) + do_vcs_install(cfg.versionfile_source, maybe_ipy) return 0 -def scan_setup_py(): +def scan_setup_py() -> int: """Validate the contents of setup.py against Versioneer's expectations.""" found = set() setters = False @@ -2055,10 +2264,14 @@ def scan_setup_py(): return errors +def setup_command() -> NoReturn: + """Set up Versioneer and exit with appropriate error code.""" + errors = do_setup() + errors += scan_setup_py() + sys.exit(1 if errors else 0) + + if __name__ == "__main__": cmd = sys.argv[1] if cmd == "setup": - errors = do_setup() - errors += scan_setup_py() - if errors: - sys.exit(1) + setup_command()