ChessAnalysisPipeline 0.0.5__py3-none-any.whl → 0.0.6__py3-none-any.whl

CHAP/common/writer.py

@@ -1,67 +1,70 @@
 #!/usr/bin/env python
-'''
+"""
 File       : writer.py
 Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
 Description: Module for Writers used in multiple experiment-specific workflows.
-'''
+"""
 
 # system modules
-import argparse
-import json
-import logging
 import os
-import sys
 
 # local modules
 from CHAP import Writer
 
+
 class ExtractArchiveWriter(Writer):
+    """Writer for tar files from binary data"""
     def _write(self, data, filename):
-        '''Take a .tar archive represented as bytes in `data` and write the
-        extracted archive to files.
+        """Take a .tar archive represented as bytes in `data` and
+        write the extracted archive to files.
 
         :param data: the archive data
         :type data: bytes
-        :param filename: the name of a directory to which the archive files will
-            be written
+        :param filename: the name of a directory to which the archive
+            files will be written
         :type filename: str
         :return: the original `data`
         :rtype: bytes
-        '''
+        """
 
         from io import BytesIO
         import tarfile
 
-        tar = tarfile.open(fileobj=BytesIO(data))
-        tar.extractall(path=filename)
+        with tarfile.open(fileobj=BytesIO(data)) as tar:
+            tar.extractall(path=filename)
+
+        return data
 
-        return(data)
 
 class NexusWriter(Writer):
+    """Writer for NeXus files from `NXobject`-s"""
     def _write(self, data, filename, force_overwrite=False):
-        '''Write `data` to a NeXus file
+        """Write `data` to a NeXus file
 
         :param data: the data to write to `filename`.
         :type data: nexusformat.nexus.NXobject
         :param filename: name of the file to write to.
         :param force_overwrite: flag to allow data in `filename` to be
-            overwritten, if it already exists. 
+            overwritten, if it already exists.
         :return: the original input data
-        '''
+        """
 
         from nexusformat.nexus import NXobject
-        
+
         if not isinstance(data, NXobject):
-            raise(TypeError(f'Cannot write object of type {type(data).__name__} to a NeXus file.'))
+            raise TypeError('Cannot write object of type '
+                            f'{type(data).__name__} to a NeXus file.')
 
         mode = 'w' if force_overwrite else 'w-'
         data.save(filename, mode=mode)
 
-        return(data)
+        return data
+
 
 class YAMLWriter(Writer):
+    """Writer for YAML files from `dict`-s"""
     def _write(self, data, filename, force_overwrite=False):
-        '''If `data` is a `dict`, write it to `filename`.
+        """If `data` is a `dict`, write it to `filename`.
 
         :param data: the dictionary to write to `filename`.
         :type data: dict
@@ -75,21 +78,24 @@ class YAMLWriter(Writer):
             `force_overwrite` is `False`.
         :return: the original input data
         :rtype: dict
-        '''
+        """
 
         import yaml
 
         if not isinstance(data, (dict, list)):
-            raise(TypeError(f'{self.__name__}.write: input data must be a dict or list.'))
+            raise TypeError(
+                f'{self.__name__}.write: input data must be a dict or list.')
 
         if not force_overwrite:
             if os.path.isfile(filename):
-                raise(RuntimeError(f'{self.__name__}: {filename} already exists.'))
+                raise RuntimeError(
+                    f'{self.__name__}: {filename} already exists.')
 
         with open(filename, 'w') as outf:
             yaml.dump(data, outf, sort_keys=False)
 
-        return(data)
+        return data
+
 
 if __name__ == '__main__':
     from CHAP.writer import main

CHAP/edd/models.py

@@ -1,3 +1,4 @@
+# third party modules
 import numpy as np
 from pathlib import PosixPath
 from pydantic import (BaseModel,
@@ -12,14 +13,15 @@ from typing import Optional
 
 
 class MCACeriaCalibrationConfig(BaseModel):
-    '''Class representing metadata required to perform a Ceria calibration for an
+    """
+    Class representing metadata required to perform a Ceria calibration for an
     MCA detector.
 
     :ivar spec_file: Path to the SPEC file containing the CeO2 scan
     :ivar scan_number: Number of the CeO2 scan in `spec_file`
     :ivar scan_step_index: Index of the scan step to use for calibration,
-        optional. If not specified, the calibration routine will be performed on
-        the average of all MCA spectra for the scan.
+        optional. If not specified, the calibration routine will be performed
+        on the average of all MCA spectra for the scan.
 
     :ivar flux_file: csv file containing station beam energy in eV (column 0)
         and flux (column 1)
@@ -28,8 +30,8 @@ class MCACeriaCalibrationConfig(BaseModel):
     :ivar num_bins: number of channels on the MCA to calibrate
     :ivar max_energy_kev: maximum channel energy of the MCA in keV
 
-    :ivar hexrd_h5_material_file: path to a HEXRD materials.h5 file containing an
-        entry for the material properties.
+    :ivar hexrd_h5_material_file: path to a HEXRD materials.h5 file containing
+        an entry for the material properties.
     :ivar hexrd_h5_material_name: Name of the material entry in
         `hexrd_h5_material_file`, defaults to `'CeO2'`.
     :ivar lattice_parameter_angstrom: lattice spacing in angstrom to use for
@@ -59,9 +61,9 @@ class MCACeriaCalibrationConfig(BaseModel):
     :ivar max_iter: maximum number of iterations of the calibration routine,
         defaults to `10`.
     :ivar tune_tth_tol: stop iteratively tuning 2&theta when an iteration
-        produces a change in the tuned value of 2&theta that is smaller than this
-        value, defaults to `1e-8`.
-    '''
+        produces a change in the tuned value of 2&theta that is smaller than
+        this value, defaults to `1e-8`.
+    """
 
     spec_file: FilePath
     scan_number: conint(gt=0)
@@ -74,7 +76,8 @@ class MCACeriaCalibrationConfig(BaseModel):
     max_energy_kev: confloat(gt=0)
 
     hexrd_h5_material_file: FilePath
-    hexrd_h5_material_name: constr(strip_whitespace=True, min_length=1) = 'CeO2'
+    hexrd_h5_material_name: constr(
+        strip_whitespace=True, min_length=1) = 'CeO2'
     lattice_parameter_angstrom: confloat(gt=0) = 5.41153
 
     tth_max: confloat(gt=0, allow_inf_nan=False) = 90.0
@@ -98,20 +101,22 @@ class MCACeriaCalibrationConfig(BaseModel):
 
     @validator('fit_include_bin_ranges', each_item=True)
     def validate_include_bin_range(cls, value, values):
-        '''Ensure no bin ranges are outside the boundary of the detector'''
+        """Ensure no bin ranges are outside the boundary of the detector"""
 
         num_bins = values.get('num_bins')
         value[1] = min(value[1], num_bins)
-        return(value)
+        return value
 
     def mca_data(self):
-        '''Get the 1D array of MCA data to use for calibration.
-        
+        """Get the 1D array of MCA data to use for calibration.
+
         :return: MCA data
         :rtype: np.ndarray
-        '''
+        """
+        # local modules
+        from CHAP.common.utils.scanparsers \
+            import SMBMCAScanParser as ScanParser
 
-        from CHAP.common.utils.scanparsers import SMBMCAScanParser as ScanParser
         scanparser = ScanParser(self.spec_file, self.scan_number)
         if self.scan_step_index is None:
             data = scanparser.get_all_detector_data(self.detector_name)
@@ -120,96 +125,105 @@ class MCACeriaCalibrationConfig(BaseModel):
             else:
                 data = data[0]
         else:
-            data = scanparser.get_detector_data(self.detector_name, self.scan_step_index)
+            data = scanparser.get_detector_data(
+                self.detector_name, self.scan_step_index)
 
-        return(np.array(data))
+        return np.array(data)
 
     def mca_mask(self):
-        '''Get a boolean mask array to use on MCA data before fitting.
+        """Get a boolean mask array to use on MCA data before fitting.
 
         :return: boolean mask array
         :rtype: numpy.ndarray
-        '''
+        """
 
         mask = np.asarray([False]*self.num_bins)
         bin_indices = np.arange(self.num_bins)
         for min_, max_ in self.fit_include_bin_ranges:
-            _mask =  np.logical_and(bin_indices > min_, bin_indices < max_)
+            _mask = np.logical_and(bin_indices > min_, bin_indices < max_)
             mask = np.logical_or(mask, _mask)
 
-        return(mask)
+        return mask
 
     def flux_correction_interpolation_function(self):
-        '''Get an interpolation function to correct MCA data for relative energy
+        """
+        Get an interpolation function to correct MCA data for relative energy
         flux of the incident beam.
 
         :return: energy flux correction interpolation function
         :rtype: scipy.interpolate._polyint._Interpolator1D
-        '''
+        """
 
         flux = np.loadtxt(self.flux_file)
         energies = flux[:,0]/1.e3
         relative_intensities = flux[:,1]/np.max(flux[:,1])
         interpolation_function = interp1d(energies, relative_intensities)
-        return(interpolation_function)
+        return interpolation_function
 
     def material(self):
-        '''Get CeO2 as a `CHAP.common.utils.material.Material` object.
+        """Get CeO2 as a `CHAP.common.utils.material.Material` object.
 
         :return: CeO2 material
         :rtype: CHAP.common.utils.material.Material
-        '''
-
+        """
+        # local modules
         from CHAP.common.utils.material import Material
-        material = Material(material_name=self.hexrd_h5_material_name,
-                            material_file=self.hexrd_h5_material_file,
-                            lattice_parameters_angstroms=self.lattice_parameter_angstrom)
+
+        material = Material(
+            material_name=self.hexrd_h5_material_name,
+            material_file=self.hexrd_h5_material_file,
+            lattice_parameters_angstroms=self.lattice_parameter_angstrom)
         # The following kwargs will be needed if we allow the material to be
         # built using xrayutilities (for now, we only allow hexrd to make the
         # material):
-                            # sgnum=225,
-                            # atoms=['Ce4p', 'O2mdot'],
-                            # pos=[(0.,0.,0.), (0.25,0.75,0.75)],
-                            # enrgy=50000.) # Why do we need to specify an energy to get HKLs when using xrayutilities?
-        return(material)
+        #   sgnum=225,
+        #   atoms=['Ce4p', 'O2mdot'],
+        #   pos=[(0.,0.,0.), (0.25,0.75,0.75)],
+        #   enrgy=50000.)
+        # Why do we need to specify an energy to get HKLs when using
+        # xrayutilities?
+        return material
 
     def unique_ds(self):
-        '''Get a list of unique HKLs and their lattice spacings
-        
+        """Get a list of unique HKLs and their lattice spacings
+
         :return: unique HKLs and their lattice spacings in angstroms
         :rtype: np.ndarray, np.ndarray
-        '''
-        
-        unique_hkls, unique_ds = self.material().get_unique_ds(tth_tol=self.hkl_tth_tol, tth_max=self.tth_max)
+        """
 
-        return(unique_hkls, unique_ds)
+        unique_hkls, unique_ds = self.material().get_ds_unique(
+            tth_tol=self.hkl_tth_tol, tth_max=self.tth_max)
+
+        return unique_hkls, unique_ds
 
     def fit_ds(self):
-        '''Get a list of HKLs and their lattice spacings that will be fit in the
+        """
+        Get a list of HKLs and their lattice spacings that will be fit in the
         calibration routine
-        
+
         :return: HKLs to fit and their lattice spacings in angstroms
         :rtype: np.ndarray, np.ndarray
-        '''
-        
+        """
+
         unique_hkls, unique_ds = self.unique_ds()
 
         fit_hkls = np.array([unique_hkls[i] for i in self.fit_hkls])
         fit_ds = np.array([unique_ds[i] for i in self.fit_hkls])
 
-        return(fit_hkls, fit_ds)
+        return fit_hkls, fit_ds
 
     def dict(self):
-        '''Return a representation of this configuration in a dictionary that is
+        """
+        Return a representation of this configuration in a dictionary that is
         suitable for dumping to a YAML file (one that converts all instances of
         fields with type `PosixPath` to `str`).
 
         :return: dictionary representation of the configuration.
         :rtype: dict
-        '''
+        """
 
         d = super().dict()
         for k,v in d.items():
             if isinstance(v, PosixPath):
                 d[k] = str(v)
-        return(d)
+        return d