Pre release (#15)

* Prepare for v0.0.9 release (#14)

* Add polarised experiment

* Add chi2 options

* Calculate profile up/down

* RE-implement chi2

* Add Polarization efficiency/level

* Fix fitable values

* Fix hidden refinement

* Remove auto-refine

* Temporary fix of min/max for polarization and efficiency

* Fix calculated pattern values

* Add calculated background

* Fix background for polarised neutrons

* Fixup creation of phaess and exps

* Typo fixes [ci skip]

* Fix polarisation (until cryspy is fixed)

* Fix refine polarisation

* Fix error on scale

* Don't print to the console

* Create empty cryspy obj if rcif path is None

* Fix experiments as cif

* 1st implementation of editable CIF at the back end

* Undo/redo is broken for manual editing
* Sample editing is still not fully implemented

* Fix issue with complex numbers for the scattering length

* Change space group name source

* Add exp from cif compatibility

* Add phase from cif compatibility

* Allow to run bulk update without macro

* Add datablock label to calculations cif

* Part of back-end implementation of Main.cif Edit

* Remove global_ from CIFs on saving

* Simplify writing CIF files

* Save calculations.cif to project

* Switch to master branch for cryspy

* Add calculations.cif

* Intermediate fixes

* Re-write of DictComparison

* Fix unit tests and dictTools

* fix fit tests on windows/linux

* More windows test fixes

* Fix undo/redo for list types

* More undo/redo work

* Sort Backgrounds

* Ugly hack to save name/keyword changes

* Change keyword list to string

* Sort background list of string keys numerically

* Move filenames to master obj

* Internal main_rcif to project_rcif

* Move from phases to samples

* Variable name changes

* Rename phases to sample

Co-authored-by: Andrew Sazonov <[email protected]>

* Update Release.json

Co-authored-by: Andrew Sazonov <[email protected]>

Author: wardsimon

Scripts/InstallPyPackages.py

@@ -55,8 +55,9 @@ def install(*packages):
 
     upgradePip()
 
-    installFromGit(owner='ikibalin', repo='cryspy', branch='transition-to-version-0.2', egg='cryspy_0.2.0_beta')
+    #installFromGit(owner='ikibalin', repo='cryspy', branch='transition-to-version-0.2', egg='cryspy_0.2.0_beta')
     install(
+        'cryspy',
         'dictdiffer',
         'asteval',
         'pytest',

easyInterface/Diffraction/Calculators/CryspyCalculator.py

@@ -73,8 +73,15 @@ class CalculatedPattern(LoggedPathDict):
     """
     Storage container for a calculated pattern
     """
-    def __init__(self, x: list, y_calc: list, y_diff_lower: list, y_diff_upper: list):
-        super().__init__(x=x, y_calc=y_calc, y_diff_lower=y_diff_lower, y_diff_upper=y_diff_upper)
+    def __init__(self, x: list, y_diff_lower: list, y_diff_upper: list, y_calc_up: list, y_calc_down: list = [], y_calc_bkg: list = []):
+        y_calc_down_temp = y_calc_down
+        if len(y_calc_down) == 0:
+            y_calc_down_temp = [0]*len(y_calc_up)
+
+        super().__init__(x=x, y_calc_sum=np.array(y_calc_up) + np.array(y_calc_down_temp), y_calc_diff=np.array(y_calc_up) - np.array(y_calc_down_temp),
+                         y_calc_up=y_calc_up, y_calc_down=y_calc_down,
+                         y_diff_lower=y_diff_lower, y_diff_upper=y_diff_upper,
+                         y_calc_bkg=y_calc_bkg)
         self._log = logging.getLogger(__class__.__module__)
 
     def __repr__(self):
@@ -92,17 +99,17 @@ def __init__(self, name: str, bragg_peaks: BraggPeaks, calculated_pattern: Calcu
     @classmethod
     def default(cls, name: str):
         bragg_peaks = BraggPeaks({})
-        calculated_pattern = CalculatedPattern([0], [0], [0], [0])
+        calculated_pattern = CalculatedPattern([0], [0], [0], [0],[0])
         limits = Limits()
         return cls(name, bragg_peaks, calculated_pattern, limits)
 
     @classmethod
     def fromPars(cls, name: str, bragg_crystals: CrystalBraggPeaks,
-                 y_obs_lower: list, y_obs_upper: list,
-                 tth: list, y_calc: list, y_diff_lower: list, y_diff_upper: list):
+                 y_calc_lower: list, y_calc_upper: list,
+                 tth: list, y_calc: list, y_diff_lower: list, y_diff_upper: list, y_calc_bkg: list):
         bragg_peaks = BraggPeaks(bragg_crystals)
-        calculated_pattern = CalculatedPattern(tth, y_calc, y_diff_lower, y_diff_upper)
-        limits = Limits(y_obs_lower, y_obs_upper, y_diff_upper, y_diff_lower, x_calc=tth, y_calc=y_calc)
+        calculated_pattern = CalculatedPattern(tth, y_calc, y_diff_lower, y_diff_upper, y_calc_bkg)
+        limits = Limits(y_calc_lower, y_calc_upper, y_diff_upper, y_diff_lower, x_calc=tth, y_calc=y_calc)
         return cls(name, bragg_peaks, calculated_pattern, limits)
 
     def __repr__(self):

easyInterface/Diffraction/DataClasses/DataObj/Calculation.py

@@ -18,6 +18,12 @@
         'tooltip': 'Degree offset in two theta',
         'url': '',
         'default': (0, 'deg')
+    },
+    'magnetic_field': {
+        'header': 'Field',
+        'tooltip': 'Applied magnetic field',
+        'url': '',
+        'default': (0, 'T')
     }
 }
 
@@ -48,11 +54,27 @@
     }
 }
 
+POLARIZATION_DETAILS = {
+    'polarization': {
+        'header': '',
+        'tooltip': '',
+        'url': '',
+        'default': (1, '')
+    },
+    'efficiency': {
+        'header': '',
+        'tooltip': '',
+        'url': '',
+        'default': (1, '')
+    }
+}
+
 
 class Resolution(LoggedPathDict):
     """
     Data store for the resolution parameters
     """
+
     def __init__(self, u: Base, v: Base, w: Base, x: Base, y: Base):
         """
         Dictionary store for resolution parameters
@@ -128,6 +150,7 @@ class Background(LoggedPathDict):
     """
     Data store for the background data parameters
     """
+
     def __init__(self, ttheta: float, intensity: Base):
         """
         Background dictionary
@@ -173,6 +196,7 @@ class Backgrounds(ContainerObj):
     """
     Store for a collection of background points
     """
+
     def __init__(self, backgrounds: Union[Background, dict, list]):
         """
         Constructor for Background data points
@@ -185,14 +209,24 @@ def __init__(self, backgrounds: Union[Background, dict, list]):
     def __repr__(self):
         return '{} Backgrounds'.format(len(self))
 
+    def sort(self, reverse=False):
+        keys = list(self.keys())
+        keys.sort(key=float, reverse=reverse)
+        new_bg = []
+        for key in keys:
+            new_bg.append(self[key])
+        super().__init__(new_bg, Background)
+
 
 class MeasuredPattern(LoggedPathDict):
     """
     Storage container for measured patterns
     """
-    def __init__(self, x: list, y_obs: list, sy_obs: list, y_obs_up: Union[list, None] = None, 
-                 sy_obs_up: Union[list, None] = None, y_obs_down: Union[list, None] = None, 
-                 sy_obs_down: Union[list, None] = None):
+
+    def __init__(self, x: list, y_obs: list, sy_obs: list,
+                 y_obs_diff: Union[list, None] = None, sy_obs_diff: Union[list, None] = None,
+                 y_obs_up: Union[list, None] = None, sy_obs_up: Union[list, None] = None,
+                 y_obs_down: Union[list, None] = None, sy_obs_down: Union[list, None] = None):
         """
         Constructor for a measured pattern
 
@@ -206,7 +240,8 @@ def __init__(self, x: list, y_obs: list, sy_obs: list, y_obs_up: Union[list, Non
         """
         # 1d polarised powder diffraction data
         # if y_obs_up is not None and sy_obs_up is not None and y_obs_down is not None and sy_obs_down is not None:
-        super().__init__(x=x, y_obs=y_obs, sy_obs=sy_obs, y_obs_up=y_obs_up, sy_obs_up=sy_obs_up,
+        super().__init__(x=x, y_obs=y_obs, sy_obs=sy_obs, y_obs_diff=y_obs_diff, sy_obs_diff=sy_obs_diff,
+                         y_obs_up=y_obs_up, sy_obs_up=sy_obs_up,
                          y_obs_down=y_obs_down, sy_obs_down=sy_obs_down)
         self._log = logging.getLogger(__class__.__module__)
         # # 1d unpolarised powder diffraction data
@@ -254,22 +289,27 @@ def default(cls, polarised: bool = False):
         x = []
         y_obs = []
         sy_obs = []
+        y_obs_diff = None
+        sy_obs_diff = None
         y_obs_up = None
         sy_obs_up = None
         y_obs_down = None
         sy_obs_down = None
         if polarised:
+            y_obs_diff = []
+            sy_obs_diff = []
             y_obs_up = []
             sy_obs_up = []
             y_obs_down = []
             sy_obs_down = []
-        return cls(x, y_obs, sy_obs, y_obs_up, sy_obs_up, y_obs_down, sy_obs_down)
+        return cls(x, y_obs, sy_obs, y_obs_diff, sy_obs_diff, y_obs_up, sy_obs_up, y_obs_down, sy_obs_down)
 
 
 class ExperimentPhase(LoggedPathDict):
     """
     Storage container for the Experimental Phase details
     """
+
     def __init__(self, name: str, scale: Base):
         """
         Constructor for the Experimental phase container
@@ -278,9 +318,11 @@ def __init__(self, name: str, scale: Base):
         """
         super().__init__(name=name, scale=scale)
         self._log = logging.getLogger(__class__.__module__)
+
         self.setItemByPath(['scale', 'header'], SCALE_DETAILS['scale']['header'])
         self.setItemByPath(['scale', 'tooltip'], SCALE_DETAILS['scale']['tooltip'])
         self.setItemByPath(['scale', 'url'], SCALE_DETAILS['scale']['url'])
+
         self._log.debug('Created phase: {}'.format(self))
 
     @classmethod
@@ -311,6 +353,7 @@ class ExperimentPhases(ContainerObj):
     """
     Storage of multiple phase markers associated with experiments
     """
+
     def __init__(self, experiment_phases: Union[list, ExperimentPhase, dict]):
         """
         Constructor for holding multiple experiments
@@ -324,11 +367,69 @@ def __repr__(self) -> str:
         return '{} Experimental phases'.format(len(self))
 
 
+class RefinementType(LoggedPathDict):
+    _default = {'_sum': False, '_diff': False}
+
+    def __init__(self):
+        super().__init__(**self._default)
+        self.object = None
+
+    def set_object(self, obj):
+        self.object = obj
+
+    @property
+    def sum(self):
+        return self['_sum']
+
+    @sum.setter
+    def sum(self, value):
+        if self.object is not None:
+            self.object.sum = value
+        self['_sum'] = value
+
+    @property
+    def diff(self):
+        return self['_diff']
+
+    @diff.setter
+    def diff(self, value):
+        if self.object is not None:
+            self.object.diff = value
+        self['_diff'] = value
+
+
+class Polarization(LoggedPathDict):
+    def __init__(self, polarization: Base, efficiency: Base):
+        super().__init__(polarization=polarization, efficiency=efficiency)
+
+        self.setItemByPath(['polarization', 'header'], POLARIZATION_DETAILS['polarization']['header'])
+        self.setItemByPath(['polarization', 'tooltip'], POLARIZATION_DETAILS['polarization']['tooltip'])
+        self.setItemByPath(['polarization', 'url'], POLARIZATION_DETAILS['polarization']['url'])
+
+        self.setItemByPath(['efficiency', 'header'], POLARIZATION_DETAILS['efficiency']['header'])
+        self.setItemByPath(['efficiency', 'tooltip'], POLARIZATION_DETAILS['efficiency']['tooltip'])
+        self.setItemByPath(['efficiency', 'url'], POLARIZATION_DETAILS['efficiency']['url'])
+
+    @classmethod
+    def default(cls):
+        polarization = Base(*POLARIZATION_DETAILS['polarization']['default'])
+        efficiency = Base(*POLARIZATION_DETAILS['efficiency']['default'])
+        return cls(polarization, efficiency)
+
+    @classmethod
+    def fromPars(cls, polarization, efficiency):
+        polarization = Base(polarization, POLARIZATION_DETAILS['polarization']['default'][1])
+        efficiency = Base(efficiency, POLARIZATION_DETAILS['efficiency']['default'][1])
+        return cls(polarization, efficiency)
+
+
 class Experiment(LoggedPathDict):
     """
     Experimental details data container
     """
-    def __init__(self, name: str, wavelength: Base, offset: Base, phase: ExperimentPhases, background: Backgrounds,
+
+    def __init__(self, name: str, wavelength: Base, offset: Base, magnetic_field: Base, phase: ExperimentPhases,
+                 background: Backgrounds,
                  resolution: Resolution, measured_pattern: MeasuredPattern):
         """
         Constructor for experimental data container
@@ -341,8 +442,14 @@ def __init__(self, name: str, wavelength: Base, offset: Base, phase: ExperimentP
         :param resolution: Description of the resolution
         :param measured_pattern: What was actually measured
         """
-        super().__init__(name=name, wavelength=wavelength, offset=offset, phase=phase, background=background,
-                         resolution=resolution, measured_pattern=measured_pattern)
+
+        refinement_type = RefinementType()
+        refinement_type.sum = True
+
+        super().__init__(name=name, wavelength=wavelength, offset=offset, magnetic_field=magnetic_field, phase=phase,
+                         background=background,
+                         resolution=resolution, measured_pattern=measured_pattern, refinement_type=refinement_type,
+                         polarization=Polarization.default())
         self._log = logging.getLogger(__class__.__module__)
 
         self.setItemByPath(['wavelength', 'header'], EXPERIMENT_DETAILS['wavelength']['header'])
@@ -353,6 +460,10 @@ def __init__(self, name: str, wavelength: Base, offset: Base, phase: ExperimentP
         self.setItemByPath(['offset', 'tooltip'], EXPERIMENT_DETAILS['offset']['tooltip'])
         self.setItemByPath(['offset', 'url'], EXPERIMENT_DETAILS['offset']['url'])
 
+        self.setItemByPath(['magnetic_field', 'header'], EXPERIMENT_DETAILS['magnetic_field']['header'])
+        self.setItemByPath(['magnetic_field', 'tooltip'], EXPERIMENT_DETAILS['magnetic_field']['tooltip'])
+        self.setItemByPath(['magnetic_field', 'url'], EXPERIMENT_DETAILS['magnetic_field']['url'])
+
     @classmethod
     def default(cls, name: str) -> 'Experiment':
         """
@@ -363,15 +474,16 @@ def default(cls, name: str) -> 'Experiment':
         """
         wavelength = Base(*EXPERIMENT_DETAILS['wavelength']['default'])
         offset = Base(*EXPERIMENT_DETAILS['offset']['default'])
+        field = Base(*EXPERIMENT_DETAILS['magnetic_field']['default'])
         phase = ExperimentPhases({})
         backgrounds = Backgrounds(Background.default())
         resolution = Resolution.default()
         measured_pattern = MeasuredPattern.default()
-        return cls(name, wavelength, offset, phase, backgrounds, resolution, measured_pattern)
+        return cls(name, wavelength, offset, field, phase, backgrounds, resolution, measured_pattern)
 
     @classmethod
     def fromPars(cls, name: str, wavelength: float, offset: float, scale: float, background: Backgrounds,
-                 resolution: Resolution, measured_pattern: MeasuredPattern) -> 'Experiment':
+                 resolution: Resolution, measured_pattern: MeasuredPattern, magnetic_field: float = None) -> 'Experiment':
         """
         Constructor of experiment from parameters
 
@@ -386,8 +498,12 @@ def fromPars(cls, name: str, wavelength: float, offset: float, scale: float, bac
         """
         wavelength = Base(wavelength, EXPERIMENT_DETAILS['wavelength']['default'][1])
         offset = Base(offset, EXPERIMENT_DETAILS['offset']['default'][1])
+        if magnetic_field is None:
+            magnetic_field = Base(*EXPERIMENT_DETAILS['magnetic_field']['default'])
+        else:
+            magnetic_field = Base(magnetic_field, EXPERIMENT_DETAILS['magnetic_field']['default'][1])
         phase = ExperimentPhases(ExperimentPhase.fromPars(name, scale))
-        return cls(name, wavelength, offset, phase, background, resolution, measured_pattern)
+        return cls(name, wavelength, offset, magnetic_field, phase, background, resolution, measured_pattern)
 
     def __repr__(self):
         return 'Experiment: {}'.format(self['name'])
@@ -397,6 +513,7 @@ class Experiments(ContainerObj):
     """
     Container for multiple experiments
     """
+
     def __init__(self, experiments: Union[Experiment, dict, list]):
         """
         Constructor for holding multiple experiments

easyInterface/Diffraction/DataClasses/DataObj/Experiment.py

@@ -169,7 +169,7 @@ def fromXYZ(cls, atom_site_label: str, type_symbol: str, x: float, y: float, z:
         return obj
 
     @classmethod
-    def fromPars(cls, atom_site_label: str, type_symbol: str, scat_length_neutron: float,
+    def fromPars(cls, atom_site_label: str, type_symbol: str, scat_length_neutron: complex,
                  fract_x: float, fract_y: float, fract_z: float, occupancy: float, adp_type: str,
                  U_iso_or_equiv: float, ADp: list = None, MSp: list = None) -> 'Atom':
         """