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

CHAP/edd/processor.py

@@ -1,34 +1,39 @@
 #!/usr/bin/env python
 #-*- coding: utf-8 -*-
 #pylint: disable=
-'''
+"""
 File       : processor.py
 Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
 Description: Module for Processors used only by EDD experiments
-'''
+"""
 
 # system modules
-import json
+from json import dumps
+
+# third party modules
+import numpy as np
 
 # local modules
 from CHAP.processor import Processor
-from CHAP.common import StrainAnalysisProcessor
+
 
 class MCACeriaCalibrationProcessor(Processor):
-    '''A Processor using a CeO2 scan to obtain tuned values for the bragg
-    diffraction angle and linear correction parameters for MCA channel energies
-    for an EDD experimental setup.
-    '''
+    """A Processor using a CeO2 scan to obtain tuned values for the
+    bragg diffraction angle and linear correction parameters for MCA
+    channel energies for an EDD experimental setup.
+    """
 
     def _process(self, data):
-        '''Return tuned values for 2&theta and linear correction parameters for
-        the MCA channel energies.
+        """Return tuned values for 2&theta and linear correction
+        parameters for the MCA channel energies.
 
-        :param data: input configuration for the raw data & tuning procedure
+        :param data: input configuration for the raw data & tuning
+            procedure
         :type data: list[dict[str,object]]
-        :return: original configuration dictionary with tuned values added
+        :return: original configuration dictionary with tuned values
+            added
         :rtype: dict[str,float]
-        '''
+        """
 
         calibration_config = self.get_config(data)
 
@@ -38,22 +43,23 @@ class MCACeriaCalibrationProcessor(Processor):
         calibration_config.slope_calibrated = slope
         calibration_config.intercept_calibrated = intercept
 
-        return(calibration_config.dict())
+        return calibration_config.dict()
 
     def get_config(self, data):
-        '''Get an instance of the configuration object needed by this
+        """Get an instance of the configuration object needed by this
         `Processor` from a returned value of `Reader.read`
 
-        :param data: Result of `Reader.read` where at least one item has the
-            value `'MCACeriaCalibrationConfig'` for the `'schema'` key.
+        :param data: Result of `Reader.read` where at least one item
+            has the value `'MCACeriaCalibrationConfig'` for the
+            `'schema'` key.
         :type data: list[dict[str,object]]
-        :raises Exception: If a valid config object cannot be constructed from
-            `data`.
-        :return: a valid instance of a configuration object with field values
-            taken from `data`.
+        :raises Exception: If a valid config object cannot be
+            constructed from `data`.
+        :return: a valid instance of a configuration object with field
+            values taken from `data`.
         :rtype: MCACeriaCalibrationConfig
-        '''
-
+        """
+        # local modules
         from CHAP.edd.models import MCACeriaCalibrationConfig
 
         calibration_config = False
@@ -65,37 +71,39 @@ class MCACeriaCalibrationProcessor(Processor):
                         break
 
         if not calibration_config:
-            raise(ValueError('No MCA ceria calibration configuration found in input data'))
+            raise ValueError(
+                'No MCA ceria calibration configuration found in input data')
 
-        return(MCACeriaCalibrationConfig(**calibration_config))
+        return MCACeriaCalibrationConfig(**calibration_config)
 
     def calibrate(self, calibration_config):
-        '''Iteratively calibrate 2&theta by fitting selected peaks of an MCA
-        spectrum until the computed strain is sufficiently small. Use the fitted
-        peak locations to determine linear correction parameters for the MCA's
-        channel energies.
+        """Iteratively calibrate 2&theta by fitting selected peaks of
+        an MCA spectrum until the computed strain is sufficiently
+        small. Use the fitted peak locations to determine linear
+        correction parameters for the MCA's channel energies.
 
-        :param calibration_config: object configuring the CeO2 calibration
-            procedure
+        :param calibration_config: object configuring the CeO2
+            calibration procedure
         :type calibration_config: MCACeriaCalibrationConfig
-        :return: calibrated values of 2&theta and linear correction parameters
-            for MCA channel energies : tth, slope, intercept
+        :return: calibrated values of 2&theta and linear correction
+            parameters for MCA channel energies : tth, slope,
+            intercept
         :rtype: float, float, float
-        '''
-
-        from CHAP.common.utils import Fit, FitMultipeak
-        import numpy as np
+        """
+        # third party modules
         from scipy.constants import physical_constants
 
-        hc = (physical_constants['Planck constant in eV/Hz'][0]
-              * physical_constants['speed of light in vacuum'][0]
-              * 1e7) # We'll work in keV and A, not eV and m.
+        # local modules
+        from CHAP.common.utils.fit import Fit, FitMultipeak
+
+        # We'll work in keV and A, not eV and m.
+        hc = 1e7 * physical_constants['Planck constant in eV/Hz'][0] \
+            * physical_constants['speed of light in vacuum'][0]
 
         # Collect raw MCA data of interest
         mca_data = calibration_config.mca_data()
-        mca_bin_energies = (np.arange(0, calibration_config.num_bins)
-                            * (calibration_config.max_energy_kev
-                               / calibration_config.num_bins))
+        mca_bin_energies = np.arange(0, calibration_config.num_bins) \
+            * (calibration_config.max_energy_kev/calibration_config.num_bins)
 
         # Mask out the corrected MCA data for fitting
         mca_mask = calibration_config.mca_mask()
@@ -103,22 +111,24 @@ class MCACeriaCalibrationProcessor(Processor):
         fit_mca_intensities = mca_data[mca_mask]
 
         # Correct raw MCA data for variable flux at different energies
-        flux_correct = calibration_config.flux_correction_interpolation_function()
+        flux_correct = \
+            calibration_config.flux_correction_interpolation_function()
         mca_intensity_weights = flux_correct(fit_mca_energies)
-        fit_mca_intensities = fit_mca_intensities / mca_intensity_weights
+        fit_mca_intensities = fit_mca_intensities/mca_intensity_weights
 
-        # Get the HKLs and lattice spacings that will be used for fitting
+        # Get the HKLs and lattice spacings that will be used for
+        # fitting
         tth = calibration_config.tth_initial_guess
         fit_hkls, fit_ds = calibration_config.fit_ds()
         c_1 = fit_hkls[:,0]**2 + fit_hkls[:,1]**2 + fit_hkls[:,2]**2
 
         for iter_i in range(calibration_config.max_iter):
 
-            ### Perform the uniform fit first ###
+            # Perform the uniform fit first
 
-            # Get expected peak energy locations for this iteration's starting
-            # value of tth
-            fit_lambda = 2.0 * fit_ds * np.sin(0.5*np.radians(tth))
+            # Get expected peak energy locations for this iteration's
+            # starting value of tth
+            fit_lambda = 2.0*fit_ds*np.sin(0.5*np.radians(tth))
             fit_E0 = hc / fit_lambda
 
             # Run the uniform fit
@@ -127,51 +137,55 @@ class MCACeriaCalibrationProcessor(Processor):
                     fit_mca_intensities,
                     fit_E0,
                     x=fit_mca_energies,
-                    fit_type='uniform')
+                    fit_type='uniform',
+                    plot=False)
 
-            # Extract values of interest from the best values for the uniform fit
-            # parameters
-            uniform_fit_centers = [best_values[f'peak{i+1}_center'] for i in range(len(calibration_config.fit_hkls))]
+            # Extract values of interest from the best values for the
+            # uniform fit parameters
+            uniform_fit_centers = [
+                best_values[f'peak{i+1}_center']
+                for i in range(len(calibration_config.fit_hkls))]
             # uniform_a = best_values['scale_factor']
             # uniform_strain = np.log(
-            #     (uniform_a 
+            #     (uniform_a
             #      / calibration_config.lattice_parameter_angstrom))
             # uniform_tth = tth * (1.0 + uniform_strain)
             # uniform_rel_rms_error = (np.linalg.norm(residual)
             #                          / np.linalg.norm(fit_mca_intensities))
 
-            ### Next, perform the unconstrained fit ###
+            # Next, perform the unconstrained fit
 
-            # Use the peak locations found in the uniform fit as the initial
-            # guesses for peak locations in the unconstrained fit
+            # Use the peak locations found in the uniform fit as the
+            # initial guesses for peak locations in the unconstrained
+            # fit
             best_fit, residual, best_values, best_errors, redchi, success = \
                 FitMultipeak.fit_multipeak(
                     fit_mca_intensities,
                     uniform_fit_centers,
                     x=fit_mca_energies,
-                    fit_type='unconstrained')
+                    fit_type='unconstrained',
+                    plot=False)
 
             # Extract values of interest from the best values for the
             # unconstrained fit parameters
             unconstrained_fit_centers = np.array(
-                [best_values[f'peak{i+1}_center'] for i in range(len(calibration_config.fit_hkls))])
-            unconstrained_a = (0.5 * hc * np.sqrt(c_1)
-                               / (unconstrained_fit_centers
-                                  * abs(np.sin(0.5*np.radians(tth)))))
+                [best_values[f'peak{i+1}_center']
+                 for i in range(len(calibration_config.fit_hkls))])
+            unconstrained_a = 0.5*hc*np.sqrt(c_1) \
+                / (unconstrained_fit_centers*abs(np.sin(0.5*np.radians(tth))))
             unconstrained_strains = np.log(
-                (unconstrained_a
-                 / calibration_config.lattice_parameter_angstrom))
+                unconstrained_a/calibration_config.lattice_parameter_angstrom)
             unconstrained_strain = np.mean(unconstrained_strains)
-            unconstrained_tth = tth * (1.0 + unconstrained_strain)
-            unconstrained_rel_rms_error = (np.linalg.norm(residual)
-                                           / np.linalg.norm(fit_mca_intensities))
-
+            unconstrained_tth = tth * (1.0+unconstrained_strain)
+            unconstrained_rel_rms_error = (
+                np.linalg.norm(residual)/np.linalg.norm(fit_mca_intensities))
 
             # Update tth for the next iteration of tuning
             prev_tth = tth
             tth = unconstrained_tth
 
-            # Stop tuning tth at this iteration if differences are small enough
+            # Stop tuning tth at this iteration if differences are
+            # small enough
             if abs(tth - prev_tth) < calibration_config.tune_tth_tol:
                 break
 
@@ -185,46 +199,49 @@ class MCACeriaCalibrationProcessor(Processor):
         slope = fit.best_values['slope']
         intercept = fit.best_values['intercept']
 
-        return(float(tth), float(slope), float(intercept))
+        return float(tth), float(slope), float(intercept)
+
 
 class MCADataProcessor(Processor):
-    '''A Processor to return data from an MCA, restuctured to incorporate the
-    shape & metadata associated with a map configuration to which the MCA data
-    belongs, and linearly transformed according to the results of a ceria
-    calibration.
-    '''
+    """A Processor to return data from an MCA, restuctured to
+    incorporate the shape & metadata associated with a map
+    configuration to which the MCA data belongs, and linearly
+    transformed according to the results of a ceria calibration.
+    """
 
     def _process(self, data):
-        '''Process configurations for a map and MCA detector(s), and return the
-        calibrated MCA data collected over the map.
+        """Process configurations for a map and MCA detector(s), and
+        return the calibrated MCA data collected over the map.
 
-        :param data: input map configuration and results of ceria calibration
+        :param data: input map configuration and results of ceria
+            calibration
         :type data: list[dict[str,object]]
         :return: calibrated and flux-corrected MCA data
         :rtype: nexusformat.nexus.NXentry
-        '''
+        """
 
         map_config, calibration_config = self.get_configs(data)
         nxroot = self.get_nxroot(map_config, calibration_config)
 
-        return(nxroot)
+        return nxroot
 
     def get_configs(self, data):
-        '''Get instances of the configuration objects needed by this
+        """Get instances of the configuration objects needed by this
         `Processor` from a returned value of `Reader.read`
 
-        :param data: Result of `Reader.read` where at least one item has the
-            value `'MapConfig'` for the `'schema'` key, and at least one item has
-            the value `'MCACeriaCalibrationConfig'` for the `'schema'` key.
+        :param data: Result of `Reader.read` where at least one item
+            has the value `'MapConfig'` for the `'schema'` key, and at
+            least one item has the value `'MCACeriaCalibrationConfig'`
+            for the `'schema'` key.
         :type data: list[dict[str,object]]
-        :raises Exception: If valid config objects cannot be constructed from
-            `data`.
-        :return: valid instances of the configuration objects with field values
-            taken from `data`.
+        :raises Exception: If valid config objects cannot be
+            constructed from `data`.
+        :return: valid instances of the configuration objects with
+            field values taken from `data`.
         :rtype: tuple[MapConfig, MCACeriaCalibrationConfig]
-        '''
-
-        from CHAP.common.models import MapConfig
+        """
+        # local modules
+        from CHAP.common.models.map import MapConfig
         from CHAP.edd.models import MCACeriaCalibrationConfig
 
         map_config = False
@@ -239,17 +256,20 @@ class MCADataProcessor(Processor):
                         calibration_config = item.get('data')
 
         if not map_config:
-            raise(ValueError('No map configuration found in input data'))
+            raise ValueError('No map configuration found in input data')
         if not calibration_config:
-            raise(ValueError('No MCA ceria calibration configuration found in input data'))
+            raise ValueError('No MCA ceria calibration configuration found in '
+                             'input data')
 
-        return(MapConfig(**map_config), MCACeriaCalibrationConfig(**calibration_config))
+        return (MapConfig(**map_config),
+                MCACeriaCalibrationConfig(**calibration_config))
 
     def get_nxroot(self, map_config, calibration_config):
-        '''Get a map of the MCA data collected by the scans in `map_config`. The
-        MCA data will be calibrated and flux-corrected according to the
-        parameters included in `calibration_config`. The data will be returned
-        along with relevant metadata in the form of a NeXus structure.
+        """Get a map of the MCA data collected by the scans in
+        `map_config`. The MCA data will be calibrated and
+        flux-corrected according to the parameters included in
+        `calibration_config`. The data will be returned along with
+        relevant metadata in the form of a NeXus structure.
 
         :param map_config: the map configuration
         :type map_config: MapConfig
@@ -257,16 +277,15 @@ class MCADataProcessor(Processor):
         :type calibration_config: MCACeriaCalibrationConfig
         :return: a map of the calibrated and flux-corrected MCA data
         :rtype: nexusformat.nexus.NXroot
-        '''
-
-        from CHAP.common import MapProcessor
-
+        """
+        # third party modules
         from nexusformat.nexus import (NXdata,
                                        NXdetector,
-                                       NXentry,
                                        NXinstrument,
                                        NXroot)
-        import numpy as np
+
+        # local modules
+        from CHAP.common import MapProcessor
 
         nxroot = NXroot()
 
@@ -275,17 +294,17 @@ class MCADataProcessor(Processor):
 
         nxentry.instrument = NXinstrument()
         nxentry.instrument.detector = NXdetector()
-        nxentry.instrument.detector.calibration_configuration = json.dumps(calibration_config.dict())
+        nxentry.instrument.detector.calibration_configuration = dumps(
+            calibration_config.dict())
 
         nxentry.instrument.detector.data = NXdata()
         nxdata = nxentry.instrument.detector.data
         nxdata.raw = np.empty((*map_config.shape, calibration_config.num_bins))
         nxdata.raw.attrs['units'] = 'counts'
-        nxdata.channel_energy = (calibration_config.slope_calibrated
-                                * np.arange(0, calibration_config.num_bins)
-                                * (calibration_config.max_energy_kev
-                                   / calibration_config.num_bins)
-                                + calibration_config.intercept_calibrated)
+        nxdata.channel_energy = calibration_config.slope_calibrated \
+            * np.arange(0, calibration_config.num_bins) \
+            * (calibration_config.max_energy_kev/calibration_config.num_bins) \
+            + calibration_config.intercept_calibrated
         nxdata.channel_energy.attrs['units'] = 'keV'
 
         for scans in map_config.spec_scans:
@@ -311,11 +330,15 @@ class MCADataProcessor(Processor):
                 nxentry.data.attrs['axes'],
                 f'{calibration_config.detector_name}_channel_energy']
         else:
-            nxentry.data.attrs['axes'] += [f'{calibration_config.detector_name}_channel_energy']
+            nxentry.data.attrs['axes'] += [
+                f'{calibration_config.detector_name}_channel_energy']
         nxentry.data.attrs['signal'] = calibration_config.detector_name
 
-        return(nxroot)
+        return nxroot
+
 
 if __name__ == '__main__':
+    # local modules
     from CHAP.processor import main
+
     main()

CHAP/edd/reader.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python  
+#!/usr/bin/env python
 
 if __name__ == '__main__':
     from CHAP.reader import main

CHAP/edd/writer.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python  
+#!/usr/bin/env python
 
 if __name__ == '__main__':
     from CHAP.writer import main

CHAP/inference/processor.py

@@ -1,11 +1,11 @@
-#!/usr/bin/env python                                                                                                       
-#-*- coding: utf-8 -*-                                                                                                      
-#pylint: disable=                                                                                                           
-'''                                                                                                                         
-File       : processor.py                                                                                                   
-Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>                                                                  
-Description: Processor module                                                                                               
-'''
+#!/usr/bin/env python
+#-*- coding: utf-8 -*-
+#pylint: disable=
+"""
+File       : processor.py
+Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
+Description: Processor module
+"""
 
 # system modules
 from time import time
@@ -13,14 +13,12 @@ from time import time
 # local modules
 from CHAP import Processor
 
+
 class TFaaSImageProcessor(Processor):
-    '''
-    A Processor to get predictions from TFaaS inference server.
-    '''
+    """A Processor to get predictions from TFaaS inference server."""
+
     def process(self, data, url, model, verbose=False):
-        '''
-        process data API
-        '''
+        """process data API"""
 
         t0 = time()
         self.logger.info(f'Executing "process" with url {url} model {model}')
@@ -29,40 +27,49 @@ class TFaaSImageProcessor(Processor):
 
         self.logger.info(f'Finished "process" in {time()-t0:.3f} seconds\n')
 
-        return(data)
+        return data
 
     def _process(self, data, url, model, verbose):
-        '''Print and return the input data.
+        """Print and return the input data.
 
-        :param data: Input image data, either file name or actual image data
+        :param data: Input image data, either file name or actual
+            image data
         :type data: object
         :return: `data`
         :rtype: object
-        '''
+        """
+        # system modules
+        from pathlib import Path
 
+        # local modules
         from MLaaS.tfaas_client import predictImage
-        from pathlib import Path
 
         self.logger.info(f'input data {type(data)}')
         if isinstance(data, str) and Path(data).is_file():
-            imgFile = data
-            data = predictImage(url, imgFile, model, verbose)
+            img_file = data
+            data = predictImage(url, img_file, model, verbose)
         else:
+            # third party modules
+            from requests import Session
+
             rdict = data[0]
-            import requests
             img = rdict['data']
-            session = requests.Session()
+            session = Session()
             rurl = url + '/predict/image'
-            payload = dict(model=model)
-            files = dict(image=img)
-            self.logger.info(f'HTTP request {rurl} with image file and {payload} payload')
-            req = session.post(rurl, files=files, data=payload )
+            payload = {'model': model}
+            files = {'image': img}
+            self.logger.info(
+                f'HTTP request {rurl} with image file and {payload} payload')
+            req = session.post(rurl, files=files, data=payload)
             data = req.content
             data = data.decode('utf-8').replace('\n', '')
             self.logger.info(f'HTTP response {data}')
 
-        return(data)
+        return data
+
 
 if __name__ == '__main__':
+    # local modules
     from CHAP.processor import main
+
     main()

CHAP/inference/reader.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python  
+#!/usr/bin/env python
 
 if __name__ == '__main__':
     from CHAP.reader import main

CHAP/inference/writer.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python  
+#!/usr/bin/env python
 
 if __name__ == '__main__':
     from CHAP.writer import main

CHAP/pipeline.py

@@ -4,21 +4,19 @@
 """
 File       : pipeline.py
 Author     : Valentin Kuznetsov <vkuznet AT gmail dot com>
-Description: 
+Description:
 """
 
 # system modules
 import logging
 from time import time
 
+
 class Pipeline():
-    """
-    Pipeline represent generic Pipeline class
-    """
+    """Pipeline represent generic Pipeline class"""
     def __init__(self, items=None, kwds=None):
-        """
-        Pipeline class constructor
-        
+        """Pipeline class constructor
+
         :param items: list of objects
         :param kwds: list of method args for individual objects
         """
@@ -31,12 +29,10 @@ class Pipeline():
         self.logger.propagate = False
 
     def execute(self):
-        """
-        execute API
-        """
+        """execute API"""
 
         t0 = time()
-        self.logger.info(f'Executing "execute"\n')
+        self.logger.info('Executing "execute"\n')
 
         data = None
         for item, kwargs in zip(self.items, self.kwds):
@@ -52,33 +48,23 @@ class Pipeline():
 
         self.logger.info(f'Executed "execute" in {time()-t0:.3f} seconds')
 
+
 class PipelineObject():
-    """
-    PipelineObject represent generic Pipeline class
-    """
-    def __init__(self, reader, writer, processor, fitter):
-        """
-        PipelineObject class constructor
-        """
+    """PipelineObject represent generic Pipeline class"""
+    def __init__(self, reader, writer, processor):
+        """PipelineObject class constructor"""
         self.reader = reader
         self.writer = writer
         self.processor = processor
 
     def read(self, filename):
-        """
-        read object API
-        """
+        """read object API"""
         return self.reader.read(filename)
 
     def write(self, data, filename):
-        """
-        write object API
-        """
+        """write object API"""
         return self.writer.write(data, filename)
 
     def process(self, data):
-        """
-        process object API
-        """
+        """process object API"""
         return self.processor.process(data)
-