Initial XPCS GUIPlugin

requirements.txt

@@ -4,4 +4,12 @@ sphinx_rtd_theme
 nose
 coverage
 pypi-publisher
+scipy
+scikit-image
+xicam.SAXS
+event-model
+intake_bluesky
+
+# Wait until ronpandolfi's changes (#542) are in release /PyPi ...
+scikit-beam @ git+https://github.com/scikit-beam/scikit-beam
 

setup.py

@@ -14,8 +14,8 @@
 with open(path.join(here, 'requirements.txt'), encoding='utf-8') as f:
     all_reqs = f.read().split('\n')
 
-install_requires = [x.strip() for x in all_reqs if 'git+' not in x]
-dependency_links = [x.strip().replace('git+', '') for x in all_reqs if x.startswith('git+')]
+install_requires = [x.strip() for x in all_reqs]# if 'git+' not in x]
+#dependency_links = [x.strip().replace('git+', '') for x in all_reqs if x.startswith('git+')]
 
 setup(
     name='xicam.XPCS',
@@ -37,6 +37,6 @@
     include_package_data=True,
     author='Ron Pandolfi',
     install_requires=install_requires,
-    dependency_links=dependency_links,
+    #dependency_links=dependency_links,
     author_email='ronpandolfi@lbl.gov'
 )

xicam/XPCS/formats/APSXPCS.py

@@ -0,0 +1,126 @@
+import time
+from pathlib import Path
+
+import event_model
+import h5py
+from intake_bluesky.in_memory import BlueskyInMemoryCatalog
+
+from xicam.core.msg import WARNING, notifyMessage
+from xicam.plugins.DataHandlerPlugin import DataHandlerPlugin
+
+
+class APSXPCS(DataHandlerPlugin):
+    """
+    Handles ingestion of APS XPCS .hdf files.
+
+    Internally, these .hdf files will hold a reference to a .bin image file,
+    which will be loaded as well.
+    """
+    name = 'APSXPCS'
+    DEFAULT_EXTENTIONS = ['.hdf', '.h5']
+
+    def __init__(self, path):
+        super(APSXPCS, self).__init__()
+        self.path = path
+
+    def __call__(self, data_key='', slc=0, **kwargs):
+        # TODO -- change to show image data once image data is being ingested
+        h5 = h5py.File(self.path, 'r')
+        if data_key == 'norm-0-g2':
+            return h5['exchange'][data_key][:,:,slc].transpose()
+        return h5['exchange'][data_key][slc]
+
+    @classmethod
+    def ingest(cls, paths):
+        updated_doc = dict()
+        # TODO -- update for multiple paths (pending dbheader interface)
+        if len(paths) > 1:
+            paths = [paths[0]]
+            message = 'Opening multiple already-processed data sources is not yet supported. '
+            message += f'Opening the first image, {paths[0]}...'
+            notifyMessage(message, level=WARNING)
+            print(f'PATHS: {paths}')
+        for name, doc in cls._createDocument(paths):
+            if name == 'start':
+                updated_doc[name] = doc
+                # TODO -- should 'sample_name' and 'paths' be something different?
+                doc['sample_name'] = cls.title(paths)
+                doc['paths'] = paths
+            if name == 'descriptor':
+                if updated_doc.get('descriptors'):
+                    updated_doc['descriptors'].append(doc)
+                else:
+                    updated_doc['descriptors'] = [doc]
+            if name == 'event':
+                if updated_doc.get('events'):
+                    updated_doc['events'].append(doc)
+                else:
+                    updated_doc['events'] = [doc]
+            if name == 'stop':
+                updated_doc[name] = doc
+
+        return updated_doc
+
+    @classmethod
+    def title(cls, paths):
+        """Returns the title of the start_doc sample_name"""
+        # return the file basename w/out extension
+        # TODO -- handle multiple paths
+        return Path(paths[0]).resolve().stem
+
+    @classmethod
+    def _createDocument(cls, paths):
+        # TODO -- add frames after being able to read in bin images
+        for path in paths:
+            timestamp = time.time()
+
+            run_bundle = event_model.compose_run()
+            yield 'start', run_bundle.start_doc
+
+            source = 'APS XPCS'  # TODO -- find embedded source info?
+            frame_data_keys = {'frame': {'source': source, 'dtype': 'number', 'shape': []}}
+            frame_stream_name = 'primary'
+            frame_stream_bundle = run_bundle.compose_descriptor(data_keys=frame_data_keys,
+                                                                name=frame_stream_name)
+            yield 'descriptor', frame_stream_bundle.descriptor_doc
+
+            # 'name' is used as an identifier for results when plotting
+            reduced_data_keys = {
+                'g2': {'source': source, 'dtype': 'number', 'shape': [61]},
+                'g2_err': {'source': source, 'dtype': 'number', 'shape': [61]},
+                'lag_steps': {'source': source, 'dtype': 'number', 'shape': [61]},
+                'fit_curve': {'source': source, 'dtype': 'number', 'shape': [61]},
+                'name': {'source': source, 'dtype': 'string', 'shape': []}
+            }
+            result_stream_name = 'reduced'
+            reduced_stream_bundle = run_bundle.compose_descriptor(data_keys=reduced_data_keys,
+                                                                  name=result_stream_name)
+            yield 'descriptor', reduced_stream_bundle.descriptor_doc
+
+            h5 = h5py.File(path, 'r')
+            frames = []
+            # TODO -- use the processed data timestamp?
+            for frame in frames:
+                yield 'event', frame_stream_bundle.compose_event(data={'frame', frame},
+                                                                 timestamps={'frame', timestamp})
+
+            lag_steps = h5['exchange']['tau'][()]
+            roi_list = h5['xpcs']['dqlist'][()].squeeze()
+            for g2, err, fit_curve, roi in zip(h5['exchange']['norm-0-g2'][()].T,
+                                    h5['exchange']['norm-0-stderr'][()].T,
+                                    h5['exchange']['g2avgFIT1'][()].T,
+                                    roi_list):
+                yield 'event', reduced_stream_bundle.compose_event(
+                    data={'g2': g2,
+                          'g2_err': err,
+                          'lag_steps': lag_steps,
+                          'fit_curve': fit_curve,
+                          'name': f'q = {roi:.3g}'},
+                    # TODO -- timestamps from h5?
+                    timestamps={'g2': timestamp,
+                                'g2_err': timestamp,
+                                'lag_steps': timestamp,
+                                'fit_curve': timestamp,
+                                'name': timestamp})
+
+            yield 'stop', run_bundle.compose_stop()

xicam/XPCS/formats/APSXPCS.yapsy-plugin

@@ -0,0 +1,3 @@
+[Core]
+Name = xicam.XPCS.formats.APSXPCS
+Module = APSXPCS.py

xicam/XPCS/processing/fitting.py

@@ -0,0 +1,62 @@
+import numpy as np
+import skbeam.core.correlation as corr
+from astropy.modeling import Fittable1DModel, Parameter, fitting
+
+from xicam.plugins import Input, InputOutput, Output, ProcessingPlugin
+
+
+class ScatteringModel(Fittable1DModel):
+    inputs = ('lag_steps',)
+    outputs = ('g2',)
+
+    relaxation_rate = Parameter()
+
+    def __init__(self, beta, baseline=1.0, **kwargs):
+        self.beta = beta
+        self.baseline = baseline
+        super(ScatteringModel, self).__init__(**kwargs)
+
+    def evaluate(self, lag_steps, relaxation_rate):
+        return corr.auto_corr_scat_factor(lag_steps, self.beta, relaxation_rate, self.baseline)
+
+    def fit_deriv(self, lag_steps, relaxation_rate):
+        d_relaxation_rate = -2 * self.beta * relaxation_rate * np.exp(-2 * relaxation_rate * lag_steps)
+        return [d_relaxation_rate]
+
+
+class FitScatteringFactor(ProcessingPlugin):
+    name = "Fit Scattering Factor"
+
+    g2 = InputOutput(description="normalized intensity-intensity time autocorrelation",
+                     type=np.ndarray,
+                     visible=False)
+    lag_steps = InputOutput(description="delay time",
+                            type=np.ndarray,
+                            visible=False)
+
+    beta = Input(description="optical contrast (speckle contrast), a sample-independent beamline parameter",
+                 type=float,
+                 name="speckle contrast",
+                 default=1.0)
+    baseline = Input(description="baseline of one time correlation equal to one for ergodic samples",
+                     type=float,
+                     default=1.0)
+    correlation_threshold = Input("threshold defining which g2 values to fit",
+                                  type=float,
+                                  default=1.5)
+
+    fit_curve = Output(description="fitted model of the g2 curve",
+                       type=np.ndarray)
+    relaxation_rate = Output(description="relaxation time associated with the samples dynamics",
+                             type=float)
+
+    def evaluate(self):
+        relaxation_rate = 0.01  # Some initial guess
+        model = ScatteringModel(self.beta.value, self.baseline.value, relaxation_rate=relaxation_rate)
+        fitter = fitting.SLSQPLSQFitter()
+        threshold = min(len(self.lag_steps.value), np.argmax(self.g2.value < self.correlation_threshold.value))
+
+        fit = fitter(model, self.lag_steps.value[:threshold], self.g2.value[:threshold])
+
+        self.relaxation_rate.value = fit.relaxation_rate.value
+        self.fit_curve.value = fit(self.lag_steps.value)

xicam/XPCS/processing/fitting.yapsy-plugin

@@ -0,0 +1,4 @@
+[Core]
+Name = xicam.XPCS.processing.fitting.FitScatteringFactor
+Module = fitting.py
+

xicam/XPCS/processing/fourierautocorrelator.py

@@ -5,12 +5,12 @@
 
 
 class FourierCorrelation(ProcessingPlugin):
-    data = Input(description='Array of two or more dimensions.', type=np.ndarray)
+    data = Input(description='Array of two or more dimensions.', type=np.ndarray, visible=False)
 
     labels = Input(description="""Labeled array of the same shape as the image stack.
         Each ROI is represented by sequential integers starting at one.  For
         example, if you have four ROIs, they must be labeled 1, 2, 3,
-        4. Background is labeled as 0""", type=np.array)
+        4. Background is labeled as 0""", type=np.ndarray, visible=False)
 
     g2 = Output(description="""the normalized correlation shape is (len(lag_steps), num_rois)""", type=np.array)
 

xicam/XPCS/processing/onetime.py

@@ -1,25 +1,36 @@
-from xicam.plugins import ProcessingPlugin, Input, Output, InOut
-import skbeam.core.correlation as corr
 import numpy as np
+import skbeam.core.correlation as corr
+
+from xicam.plugins import Input, Output, ProcessingPlugin
 
 
 class OneTimeCorrelation(ProcessingPlugin):
-    data = Input(description='Array of two or more dimensions.', type=np.ndarray)
+    data = Input(description='Array of two or more dimensions.', type=np.ndarray, visible=False)
 
-    labels = Input(description="""Labeled array of the same shape as the image stack.
+    labels = Input(description='''Labeled array of the same shape as the image stack.
         Each ROI is represented by sequential integers starting at one.  For
         example, if you have four ROIs, they must be labeled 1, 2, 3,
-        4. Background is labeled as 0""", type=np.array)
-    num_levels = Input(description="""how many generations of downsampling to perform, i.e., the depth of
-        the binomial tree of averaged frames""", type=int, default=7)
-    num_bufs = Input(description="""must be even
-        maximum lag step to compute in each generation of downsampling""", type=int, default=8)
+        4. Background is labeled as 0''',
+                   type=np.ndarray,
+                   visible=False)
+    # Set to num_levels to 1 if multi-tau correlation isn't desired,
+    # then set num_bufs to number of images you wish to correlate
+    num_levels = Input(description='''How many generations of downsampling to perform, i.e., the depth of
+        the binomial tree of averaged frames''',
+                       type=int,
+                       default=1,
+                       name='number of levels')
+    num_bufs = Input(description='must be even maximum lag step to compute in each generation of downsampling',
+                     type=int,
+                     default=1000,
+                     name='number of buffers')
 
-    g2 = Output(description="""the normalized correlation shape is (len(lag_steps), num_rois)""", type=np.array)
+    g2 = Output(description='the normalized correlation shape is (len(lag_steps), num_rois)',
+                type=np.ndarray)
+    lag_steps = Output(type=np.ndarray)
 
     def evaluate(self):
-        self.g2.value, lag_steps = corr.multi_tau_auto_corr(self.num_levels.value,
-                                                            self.num_bufs.value,
-                                                            self.labels.value.astype(np.int),
-                                                            np.array(self.data.value).astype(np.int))
-        # seems to only work with ints
+        self.g2.value, self.lag_steps.value = corr.multi_tau_auto_corr(self.num_levels.value,
+                                                                       self.num_bufs.value,
+                                                                       self.labels.value.astype(np.int),
+                                                                       np.asarray(self.data.value))