[WIP] multidetector xrf fits

PyMca5/PyMcaCore/DataObject.py

@@ -1,4 +1,4 @@
-#/*##########################################################################
+# /*##########################################################################
 #
 # The PyMca X-Ray Fluorescence Toolkit
 #
@@ -32,8 +32,9 @@
 __copyright__ = "European Synchrotron Radiation Facility, Grenoble, France"
 import numpy
 
+
 class DataObject(object):
-    '''
+    """
     Simple container of an array and associated information.
     Basically it has the members:
     info: A dictionary
@@ -47,15 +48,16 @@ class DataObject(object):
     x: A list containing arrays to be considered axes
     y: A list of data to be considered as signals
     m: A list containing the monitor data
-    '''
+    """
+
     GETINFO_DEPRECATION_WARNING = True
     GETDATA_DEPRECATION_WARNING = True
     SELECT_DEPRECATION_WARNING = True
 
     def __init__(self):
-        '''
+        """
         Default Constructor
-        '''
+        """
         self.info = {}
         self.data = numpy.array([])
 
@@ -68,7 +70,7 @@ def getInfo(self):
         """
         if DataObject.GETINFO_DEPRECATION_WARNING:
             print("DEPRECATION WARNING: DataObject.getInfo()")
-            DataObject.GETINFO_DEPRECATION_WARNING  = False
+            DataObject.GETINFO_DEPRECATION_WARNING = False
         return self.info
 
     def getData(self):
@@ -77,7 +79,7 @@ def getData(self):
         """
         if DataObject.GETDATA_DEPRECATION_WARNING:
             print("DEPRECATION WARNING: DataObject.getData()")
-            DataObject.GETDATA_DEPRECATION_WARNING  = False
+            DataObject.GETDATA_DEPRECATION_WARNING = False
         return self.data
 
     def select(self, selection=None):
@@ -89,78 +91,79 @@ def select(self, selection=None):
             DataObject.SELECT_DEPRECATION_WARNING = False
         dataObject = DataObject()
         dataObject.info = self.info
-        dataObject.info['selection'] = selection
+        dataObject.info["selection"] = selection
         if selection is None:
             dataObject.data = self.data
             return dataObject
         if type(selection) == dict:
-            #dataObject.data = self.data #should I set it to none???
+            # dataObject.data = self.data #should I set it to none???
             dataObject.data = None
-            if 'rows' in selection:
+            if "rows" in selection:
                 dataObject.x = None
                 dataObject.y = None
                 dataObject.m = None
-                if 'x' in selection['rows']:
-                    for rownumber in selection['rows']['x']:
+                if "x" in selection["rows"]:
+                    for rownumber in selection["rows"]["x"]:
                         if rownumber is None:
                             continue
                         if dataObject.x is None:
                             dataObject.x = []
                         dataObject.x.append(self.data[rownumber, :])
 
-                if 'y' in selection['rows']:
-                    for rownumber in selection['rows']['y']:
+                if "y" in selection["rows"]:
+                    for rownumber in selection["rows"]["y"]:
                         if rownumber is None:
                             continue
                         if dataObject.y is None:
                             dataObject.y = []
                         dataObject.y.append(self.data[rownumber, :])
 
-                if 'm' in selection['rows']:
-                    for rownumber in selection['rows']['m']:
+                if "m" in selection["rows"]:
+                    for rownumber in selection["rows"]["m"]:
                         if rownumber is None:
                             continue
                         if dataObject.m is None:
                             dataObject.m = []
                         dataObject.m.append(self.data[rownumber, :])
-            elif ('cols' in selection) or ('columns' in selection):
-                if 'cols' in selection:
-                    key = 'cols'
+            elif ("cols" in selection) or ("columns" in selection):
+                if "cols" in selection:
+                    key = "cols"
                 else:
-                    key = 'columns'
+                    key = "columns"
                 dataObject.x = None
                 dataObject.y = None
                 dataObject.m = None
-                if 'x' in selection[key]:
-                    for rownumber in selection[key]['x']:
+                if "x" in selection[key]:
+                    for rownumber in selection[key]["x"]:
                         if rownumber is None:
                             continue
                         if dataObject.x is None:
                             dataObject.x = []
                         dataObject.x.append(self.data[:, rownumber])
 
-                if 'y' in selection[key]:
-                    for rownumber in selection[key]['y']:
+                if "y" in selection[key]:
+                    for rownumber in selection[key]["y"]:
                         if rownumber is None:
                             continue
                         if dataObject.y is None:
                             dataObject.y = []
                         dataObject.y.append(self.data[:, rownumber])
 
-                if 'm' in selection[key]:
-                    for rownumber in selection[key]['m']:
+                if "m" in selection[key]:
+                    for rownumber in selection[key]["m"]:
                         if rownumber is None:
                             continue
                         if dataObject.m is None:
                             dataObject.m = []
                         dataObject.m.append(self.data[:, rownumber])
             if dataObject.x is None:
-                if 'Channel0' in dataObject.info:
-                    ch0 = int(dataObject.info['Channel0'])
+                if "Channel0" in dataObject.info:
+                    ch0 = int(dataObject.info["Channel0"])
                 else:
                     ch0 = 0
-                dataObject.x = [numpy.arange(ch0,
-                             ch0 + len(dataObject.y[0])).astype(numpy.float64)]
+                dataObject.x = [
+                    numpy.arange(ch0, ch0 + len(dataObject.y[0])).astype(numpy.float64)
+                ]
             if not ("selectiontype" in dataObject.info):
                 dataObject.info["selectiontype"] = "%dD" % len(dataObject.y)
             return dataObject

PyMca5/PyMcaGui/physics/xrf/McaAdvancedFit.py

@@ -58,10 +58,10 @@
     #not a big problem
     pass
 
-from PyMca5.PyMcaPhysics.xrf import ClassMcaTheory
-FISX = ClassMcaTheory.FISX
+from PyMca5.PyMcaPhysics.xrf import LegacyMcaTheory
+FISX = LegacyMcaTheory.FISX
 if FISX:
-    FisxHelper = ClassMcaTheory.FisxHelper
+    FisxHelper = LegacyMcaTheory.FisxHelper
 from . import FitParam
 from . import McaAdvancedTable
 from . import QtMcaAdvancedFitReport
@@ -291,7 +291,7 @@ def __init__(self, parent=None, name="PyMca - McaAdvancedFit",fl=0,
         self.matrixXRFMCSpectrumButton.setToolTip('Calculate Matrix Spectrum Using Monte Carlo')
         self.peaksSpectrumButton.setToolTip('Toggle Individual Peaks Spectrum Calculation On/Off')
 
-        self.mcafit   = ClassMcaTheory.McaTheory()
+        self.mcafit   = LegacyMcaTheory.McaTheory()
 
         self.fitButton.clicked.connect(self.fit)
         self.printButton.clicked.connect(self.printActiveTab)

PyMca5/PyMcaGui/physics/xrf/XRFMCPyMca.py

@@ -805,7 +805,7 @@ def _start(self):
             #perform a dummy fit till xmimsim-pymca is upgraded
             if 0:
                 import numpy
-                from PyMca import ClassMcaTheory
+                from PyMca import LegacyMcaTheory
                 newFile['fit']['linearfitflag']=1
                 newFile['fit']['stripflag']=0
                 newFile['fit']['stripiterations']=0
@@ -814,7 +814,7 @@ def _start(self):
                 #xdata = numpy.arange(xmin, xmax + 1) * 1.0
                 xdata = numpy.arange(0, xmax + 1) * 1.0
                 ydata = 0.0 + 0.1 * xdata
-                mcaFit = ClassMcaTheory.McaTheory()
+                mcaFit = LegacyMcaTheory.McaTheory()
                 mcaFit.configure(newFile)
                 mcaFit.setData(x=xdata, y=ydata, xmin=xmin, xmax=xmax)
                 mcaFit.estimate()

PyMca5/PyMcaMath/fitting/model/CachingLinkedModel.py

@@ -0,0 +1,53 @@
+import numpy
+
+from .LinkedModel import LinkedModel
+from .CachingModel import CachedPropertiesModel
+
+
+class CachedPropertiesLinkModel(CachedPropertiesModel, LinkedModel):
+    def _iter_cached_property_ids(self, **cacheoptions):
+        if self.is_linked and self._in_property_caching_context():
+            # Yield only the property id's that belong to this model
+            names = self._cached_property_names()
+            for propid in super()._iter_cached_property_ids(**cacheoptions):
+                if propid.property_name in names:
+                    yield propid
+        else:
+            yield from super()._iter_cached_property_ids(**cacheoptions)
+
+    def _get_property_values(self, **cacheoptions):
+        values = super()._get_property_values(**cacheoptions)
+        return self.__extract_values(values, **cacheoptions)
+
+    def _set_property_values(self, values, **cacheoptions):
+        values = self.__insert_values(values, **cacheoptions)
+        super()._set_property_values(values, **cacheoptions)
+
+    def __extract_values(self, values, **cacheoptions):
+        if not self.is_linked:
+            return values
+        # Only the values that belong to this model
+        data = list()
+        for propid in self._iter_cached_property_ids(**cacheoptions):
+            index = self._propid_to_index(propid, **cacheoptions)
+            data.append(numpy.atleast_1d(values[index]).tolist())
+
+        return numpy.concatenate(data)
+
+    def __insert_values(self, values, **cacheoptions):
+        if not self.is_linked:
+            return values
+        gvalues = super()._get_property_values(**cacheoptions)
+        i = 0
+        for propid in self._iter_cached_property_ids(**cacheoptions):
+            index = self._propid_to_index(propid, **cacheoptions)
+            try:
+                n = len(gvalues[index])
+            except TypeError:
+                n = 1
+            if n == 1:
+                gvalues[index] = values[i]
+            else:
+                gvalues[index] = values[i : i + n]
+            i += n
+        return gvalues