Release 0.0.9

.github/workflows/pypi_publish.yml

@@ -27,6 +27,6 @@ jobs:
       run: |
         poetry build
     - name: Publish distribution 📦 to PyPI
-      uses: pypa/gh-action-pypi-publish@master
+      uses: pypa/gh-action-pypi-publish@release/v1
       with:
         password: ${{ secrets.PYPI_PASSWORD }}

.github/workflows/self_publish_alpha.yml

@@ -20,7 +20,6 @@ jobs:
     - uses: Gr1N/setup-poetry@v7
     - name: Install and build
       run: |
-        poetry version patch
         poetry build
 
     - name: Set name variable

.github/workflows/unit_test.yml

@@ -40,6 +40,12 @@ jobs:
       with:
         python-version: 3.8
 
+    - name: Enable extra repository
+      shell: bash
+      run: |
+        pip config --user set global.extra-index-url https://easyscience.github.io/pypi/
+        pip config --user set global.trusted-host easyscience.github.io
+
     - name: Some logging
       shell: bash
       run: |

CHANGELOG.md

@@ -1 +1,15 @@
+# Version 0.0.9-beta (28 Mar 2023)
+
+### New Features
+
+- Simulating and fitting Pair Distribution Function data using the [PDFFIT](https://github.com/diffpy/diffpy.pdffit2) calculation engine.
+
+### Changes
+
+- GSASII calculation engine has been removed.
+- Changed API to define `Job` object as no longer based on the `Sample` class.
+- [Xarray objects](https://github.com/pydata/xarray) are now used to store the calculation engine results.
+- Overall performance has been improved.
+
+-
 

README.md

@@ -6,7 +6,7 @@
 **easydiffractionLib** is a Python library which provides:
 * Scripting interface to simulate and analyse neutron diffraction patterns.
 * Multiple optimization algorithms to minimize models to experimental data: [Lmfit](https://lmfit.github.io/lmfit-py/), [Bumps](https://github.com/bumps/bumps) and [DFO_LS](https://github.com/numericalalgorithmsgroup/dfols).
-* Multiple calculation engines: [CrysPy](https://github.com/ikibalin/cryspy), [CrysFML](https://www.ill.eu/sites/fullprof/php/programs24b7.html?pagina=Crysfml), [GSAS-II](https://subversion.xray.aps.anl.gov/trac/pyGSAS).
+* Multiple calculation engines: [CrysPy](https://github.com/ikibalin/cryspy), [CrysFML](https://www.ill.eu/sites/fullprof/php/programs24b7.html?pagina=Crysfml).
 
 **easydiffractionLib** is the foundation of [**easyDiffraction**](https://github.com/easyScience/easyDiffraction), an intuitive application which endeavors simplifying and accelerating the analysis of diffraction experiments.
 

easyDiffractionLib/Interfaces/CFML.py

@@ -162,14 +162,21 @@ def dump_cif(self, *args, **kwargs):
             return
         # delete preexising cif files
         self.remove_cif()
+        # naive and silly workaround for something mysterious happening in easyCrystallography
+        content = str(self._phase.cif)
+        content = content.replace("H-M_ref", "H-M_alt")
         with open(self._filename, "w") as fid:
-            fid.write(str(self._phase.cif))
+            # fid.write(str(self._phase.cif))
+            fid.write(content)
         base, file = os.path.split(self._filename)
         ext = file[-3:]
         file = file[:-4]
         for idx, phase in enumerate(self._phase):
+            content = str(phase.cif)
+            content = content.replace("H-M_ref", "H-M_alt")
             with open(f"{os.path.join(base, file)}_{idx}.{ext}", "w") as fid:
-                fid.write(str(phase.cif))
+                #fid.write(str(phase.cif))
+                fid.write(content)
 
     def remove_cif(self):
         if self._filename is None:

easyDiffractionLib/Interfaces/GSASII.py

@@ -110,8 +110,8 @@ def create(self, model):
         elif issubclass(t_, Phases):
             self._phase = model
         elif t_.__name__ in ['Powder1DCW', 'powder1DCW', 'Npowder1DCW', 'Npowder1DCWunp']:
-        #     #TODO Check to see if parameters and pattern should be initialized here.
-            self.__createModel(model_key, 'powder1DCW')
+            #TODO Check to see if parameters and pattern should be initialized here.
+            self.__createModel(model)
         elif issubclass(t_, Sample):
             self.__createModel(model)
         else:

easyDiffractionLib/Interfaces/__init__.py

@@ -6,30 +6,34 @@
 import traceback
 
 
-try:
-    from easyDiffractionLib.Interfaces.cryspy import Cryspy  # noqa: F401
-except ImportError:
-    # TODO make this a proper message (use logging?)
-    print('Warning: CrysPy is not installed')
-
-
 # try:
-#     from easyDiffractionLib.Interfaces.cryspyV2 import CryspyBase  # noqa: F401
+#     from easyDiffractionLib.Interfaces.cryspy import Cryspy  # noqa: F401
 # except ImportError:
 #     # TODO make this a proper message (use logging?)
 #     print('Warning: CrysPy is not installed')
 
+
 try:
-    from easyDiffractionLib.Interfaces.CFML import CFML  # noqa: F401
+    from easyDiffractionLib.Interfaces.cryspyV2 import CryspyBase  # noqa: F401
 except ImportError:
     # TODO make this a proper message (use logging?)
-    print('Warning: CrysFML is not installed')
+    print('Warning: CrysPy is not installed')
 
 try:
-    from easyDiffractionLib.Interfaces.GSASII import GSASII  # noqa: F401
+    from easyDiffractionLib.Interfaces.CFML import CFML  # noqa: F401
 except ImportError:
     # TODO make this a proper message (use logging?)
-    print('Warning: GSAS-2 is not installed')
+    print('Warning: CrysFML is not installed')
 
+# try:
+#     from easyDiffractionLib.Interfaces.GSASII import GSASII  # noqa: F401
+# except ImportError:
+#     # TODO make this a proper message (use logging?)
+#     print('Warning: GSAS-2 is not installed')
+
+try:
+    from easyDiffractionLib.Interfaces.pdffit2 import Pdffit2  # noqa: F401
+except ImportError:
+    print('Warning: PdfFit2 is not installed')
 
 from easyDiffractionLib.Interfaces.interfaceTemplate import InterfaceTemplate

easyDiffractionLib/Interfaces/cryspy.py

@@ -48,12 +48,16 @@ class Cryspy(InterfaceTemplate):
         "Bani": "b_iso_or_equiv",
     }
     _instrument_link = {
+        "wavelength": "wavelength",
         "resolution_u": "u",
         "resolution_v": "v",
         "resolution_w": "w",
         "resolution_x": "x",
         "resolution_y": "y",
-        "wavelength": "wavelength",
+        "reflex_asymmetry_p1": "p1",
+        "reflex_asymmetry_p2": "p2",
+        "reflex_asymmetry_p3": "p3",
+        "reflex_asymmetry_p4": "p4"
     }
     _polarization_link = {
         "polarization": "polarization",
@@ -106,27 +110,42 @@ def create(self, model):
         model_key = self.__identify(model)
         if issubclass(t_, Instrument1DCWParameters):
             self.calculator.createModel(model_key, "powder1DCW")
-            # These parameters are linked to the Resolution and Setup cryspy objects
+
+            # These parameters are linked to the Resolution, Peak Asymmetry and Setup cryspy objects
             res_key = self.calculator.createResolution()
+            asymm_key = self.calculator.createReflexAsymmetry()
             setup_key = self.calculator.createSetup()
+
             keys = self._instrument_link.copy()
-            keys.pop("wavelength")
+            res_keys = {k: v for k, v in keys.items() if 'resolution' in k}
+            asymm_keys = {k: v for k, v in keys.items() if 'reflex_asymmetry' in k}
+            setup_keys = {k: v for k, v in keys.items() if 'wavelength' in k}
+
             r_list.append(
                 ItemContainer(
                     res_key,
-                    keys,
+                    res_keys,
+                    self.calculator.genericReturn,
+                    self.calculator.genericUpdate,
+                )
+            )
+            r_list.append(
+                ItemContainer(
+                    asymm_key,
+                    asymm_keys,
                     self.calculator.genericReturn,
                     self.calculator.genericUpdate,
                 )
             )
             r_list.append(
                 ItemContainer(
                     setup_key,
-                    {"wavelength": self._instrument_link["wavelength"]},
+                    setup_keys,
                     self.calculator.genericReturn,
                     self.calculator.genericUpdate,
                 )
             )
+
         if issubclass(t_, Instrument1DTOFParameters):
             self.calculator.createModel(model_key, "powder1DTOF")
             # These parameters are linked to the Resolution and Setup cryspy objects

easyDiffractionLib/Interfaces/cryspyV2.py

@@ -123,7 +123,7 @@ def create(self, model: B) -> List[ItemContainer]:
         # Interface with Spacegroup
         elif issubclass(t_, SpaceGroup):
             s_key = self.calculator.createSpaceGroup(key=model_key, name_hm_alt="P 1")
-            keys = {"_space_group_HM_name": "name_hm_alt"}
+            keys = {"hermann_mauguin": "name_hm_alt"}
             r_list.append(
                 ItemContainer(
                     s_key,
@@ -276,12 +276,16 @@ class CW(CW_type):
     """
 
     _instrument_link = {
+        "wavelength": "wavelength",
         "resolution_u": "u",
         "resolution_v": "v",
         "resolution_w": "w",
         "resolution_x": "x",
         "resolution_y": "y",
-        "wavelength": "wavelength",
+        "reflex_asymmetry_p1": "p1",
+        "reflex_asymmetry_p2": "p2",
+        "reflex_asymmetry_p3": "p3",
+        "reflex_asymmetry_p4": "p4"
     }
 
     def create(self, model: B) -> List[ItemContainer]:
@@ -292,27 +296,42 @@ def create(self, model: B) -> List[ItemContainer]:
         # Link the Instrumental parameters to the calculator.
         if issubclass(t_, Instrument1DCWParameters):
             self.calculator.createModel(model_key, "powder1DCW")
-            # These parameters are linked to the Resolution and Setup cryspy objects
+
+            # These parameters are linked to the Resolution, Peak Asymmetry and Setup cryspy objects
             res_key = self.calculator.createResolution()
+            asymm_key = self.calculator.createReflexAsymmetry()
             setup_key = self.calculator.createSetup()
+
             keys = self._instrument_link.copy()
-            keys.pop("wavelength")
+            res_keys = {k: v for k, v in keys.items() if 'resolution' in k}
+            asymm_keys = {k: v for k, v in keys.items() if 'reflex_asymmetry' in k}
+            setup_keys = {k: v for k, v in keys.items() if 'wavelength' in k}
+
             r_list.append(
                 ItemContainer(
                     res_key,
-                    keys,
+                    res_keys,
+                    self.calculator.genericReturn,
+                    self.calculator.genericUpdate,
+                )
+            )
+            r_list.append(
+                ItemContainer(
+                    asymm_key,
+                    asymm_keys,
                     self.calculator.genericReturn,
                     self.calculator.genericUpdate,
                 )
             )
             r_list.append(
                 ItemContainer(
                     setup_key,
-                    {"wavelength": self._instrument_link["wavelength"]},
+                    setup_keys,
                     self.calculator.genericReturn,
                     self.calculator.genericUpdate,
                 )
             )
+
         return r_list
 
 
@@ -579,6 +598,7 @@ def create(self, model: B) -> List[ItemContainer]:
         model_key = self._identify(model)
         base = "powder1DCWpol"
         if t_.__name__ == "Sample" or t_.__name__ in [
+            "PolPowder1DCW",
             "Powder1DCWpol",
             "powder1DCWpol",
             "Npowder1DCWpol",
@@ -625,7 +645,7 @@ def create(self, model: B) -> List[ItemContainer]:
 ## This is the main class which is called, implementing one of the above classes.
 ##
 class CryspyV2(InterfaceTemplate):
-    name = "CrysPyV2"
+    name = "CrysPy"
 
     feature_available = {
         "Npowder1DCWunp": True,
@@ -691,6 +711,36 @@ def fit_func(self, x_array: np.ndarray, *args, **kwargs) -> Union[np.ndarray, No
             )
             return calculation
 
+    def generate_pol_fit_func(
+        self,
+        x_array: np.ndarray,
+        spin_up: np.ndarray,
+        spin_down: np.ndarray,
+        components: List[Callable],
+    ) -> Callable:
+        num_components = len(components)
+        dummy_x = np.repeat(x_array[..., np.newaxis], num_components, axis=x_array.ndim)
+        calculated_y = np.array(
+            [fun(spin_up, spin_down) for fun in components]
+        ).swapaxes(0, x_array.ndim)
+
+        def pol_fit_fuction(dummy_x: np.ndarray, **kwargs) -> np.ndarray:
+            results, results_dict = self.calculator.full_calculate(
+                x_array, pol_fn=components[0], **kwargs
+            )
+            phases = list(results_dict["phases"].keys())[0]
+            up, down = (
+                results_dict["phases"][phases]["components"]["up"],
+                results_dict["phases"][phases]["components"]["down"],
+            )
+            bg = results_dict["f_background"]
+            sim_y = np.array(
+                [fun(up, down) + fun(bg, bg) for fun in components]
+            ).swapaxes(0, x_array.ndim)
+            return sim_y.flatten()
+
+        return dummy_x.flatten(), calculated_y.flatten(), pol_fit_fuction
+
     def get_hkl(
         self,
         x_array: np.ndarray = None,
@@ -720,3 +770,22 @@ def get_phase_components(self, phase_name: str) -> dict:
         if self._internal is not None:
             data = self._internal.get_phase_components(phase_name)
             return data
+
+    def full_callback(
+        self,
+        x_array: np.ndarray,
+        pol_fn: Optional[Callable[[np.ndarray, np.ndarray], np.ndarray]] = None,
+        **kwargs,
+    ) -> np.ndarray:
+        """
+        Calculate the polarization components.
+        :param x_array: points to be calculated at
+        :return: calculated points
+        """
+        if pol_fn is None:
+            pol_fn = self.up_plus_down
+        result = None
+        if self.calculator is not None:
+            result = self.calculator.full_calculate(x_array, pol_fn=pol_fn, **kwargs)
+        return result
+

easyDiffractionLib/Interfaces/interfaceTemplate.py

@@ -4,7 +4,7 @@
 from abc import ABCMeta, abstractmethod
 from typing import Tuple, List
 from easyCore import np, borg
-from easyCore.Utils.json import MSONable
+from easyCore.Objects.core import ComponentSerializer
 
 exp_type_strings = {
     'radiation_options':   ['N', 'X'],
@@ -15,7 +15,7 @@
 }
 
 
-class InterfaceTemplate(MSONable, metaclass=ABCMeta):
+class InterfaceTemplate(ComponentSerializer, metaclass=ABCMeta):
     """
     This class is a template and defines all properties that an interface should have.
     """