Changeset 672b8ab in sasview for src/sas/qtgui/Perspectives/Fitting

Timestamp:

May 10, 2017 9:36:13 AM (8 years ago)

Author:

Piotr Rozyczko <rozyczko@…>

Branches:

ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc

Children:

1bc27f1

Parents:

2da5759

Message:

Further fitpage implementation with tests SASVIEW-570

Location:

src/sas/qtgui/Perspectives/Fitting

Files:

• FitPage.py (modified) (2 diffs)
• FittingWidget.py (modified) (2 diffs)
• SmearingWidget.py (modified) (1 diff)
• UnitTesting/FitPageTest.py (added)
• UnitTesting/FittingWidgetTest.py (modified) (2 diffs)

src/sas/qtgui/Perspectives/Fitting/FitPage.py

@@ -23 +23 @@
 
         self.page_id = 0
-        self.is_data_loaded = False
+        self.data_is_loaded = False
         self.filename = ""
+        self.data = None
+        self.parameters_to_fit = []
         
         # QModels
@@ -45 +47 @@
         self.smearing_options = {}
 
+    def save(self):
+        """
+        Serialize the current state
+        """
+        pass
+
+    def load(self, location):
+        """
+        Retrieve serialized state from specified location
+        """
+        pass
+
+    def saveAsXML(self):
+        """
+        Serialize the current state
+        """
+        # Connect to PageState.to_xml(), which serializes
+        # to the existing XML with file I(Q)
+        pass
+

src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

@@ -358 +358 @@
             self.createDefaultDataset()
 
-        #state = self.currentState()
+        state = self.currentState()
 
     def onSelectStructureFactor(self):
@@ -1149 +1149 @@
         self.current_shell_displayed = index
 
+    def readFitPage(self, fp):
+        """
+        Read in state from a fitpage object and update GUI
+        """
+        assert isinstance(fp, FitPage)
+        # Main tab info
+        self.logic.data.filename = fp.filename
+        self.data_is_loaded = fp.data_is_loaded
+        self.chkPolydispersity.setCheckState(fp.is_polydisperse)
+        self.chkMagnetism.setCheckState(fp.is_magnetic)
+        self.chk2DView.setCheckState(fp.is2D)
+
+        # Update the comboboxes
+        self.cbCategory.setCurrentIndex(self.cbCategory.findText(fp.current_category))
+        self.cbModel.setCurrentIndex(self.cbModel.findText(fp.current_model))
+        if fp.current_factor:
+            self.cbStructureFactor.setCurrentIndex(self.cbStructureFactor.findText(fp.current_factor))
+
+        self.chi2 = fp.chi2
+
+        # Options tab
+        self.q_range_min = fp.fit_options[fp.MIN_RANGE]
+        self.q_range_max = fp.fit_options[fp.MAX_RANGE]
+        self.npts = fp.fit_options[fp.NPTS]
+        #fp.fit_options[fp.NPTS_FIT] = self.npts_fit
+        self.log_points = fp.fit_options[fp.LOG_POINTS]
+        self.weighting = fp.fit_options[fp.WEIGHTING]
+
+        # Models
+        #self._model_model = fp.model_model
+        #self._poly_model = fp.poly_model
+        #self._magnet_model = fp.magnetism_model
+
+        # Resolution tab
+        smearing = fp.smearing_options[fp.SMEARING_OPTION]
+        accuracy = fp.smearing_options[fp.SMEARING_ACCURACY]
+        smearing_min = fp.smearing_options[fp.SMEARING_MIN]
+        smearing_max = fp.smearing_options[fp.SMEARING_MAX]
+        self.smearing_widget.setState(smearing, accuracy, smearing_min, smearing_max)
+
+        # TODO: add polidyspersity and magnetism
+
+    def saveToFitPage(self, fp):
+        """
+        Write current state to the given fitpage
+        """
+        assert isinstance(fp, FitPage)
+
+        # Main tab info
+        fp.filename = self.logic.data.filename
+        fp.data_is_loaded = self.data_is_loaded
+        fp.is_polydisperse = self.chkPolydispersity.isChecked()
+        fp.is_magnetic = self.chkMagnetism.isChecked()
+        fp.is2D = self.chk2DView.isChecked()
+        fp.data = self.data
+
+        # Use current models - they contain all the required parameters
+        fp.model_model = self._model_model
+        fp.poly_model = self._poly_model
+        fp.magnetism_model = self._magnet_model
+
+        if self.cbCategory.currentIndex() != 0:
+            fp.current_category = str(self.cbCategory.currentText())
+            fp.current_model = str(self.cbModel.currentText())
+
+        if self.cbStructureFactor.isEnabled() and self.cbStructureFactor.currentIndex() != 0:
+            fp.current_factor = str(self.cbStructureFactor.currentText())
+        else:
+            fp.current_factor = ''
+
+        fp.chi2 = self.chi2
+        fp.parameters_to_fit = self.parameters_to_fit
+
+        # Options tab
+        fp.fit_options[fp.MIN_RANGE] = self.q_range_min
+        fp.fit_options[fp.MAX_RANGE] = self.q_range_max
+        fp.fit_options[fp.NPTS] = self.npts
+        #fp.fit_options[fp.NPTS_FIT] = self.npts_fit
+        fp.fit_options[fp.LOG_POINTS] = self.log_points
+        fp.fit_options[fp.WEIGHTING] = self.weighting
+
+        # Resolution tab
+        smearing, accuracy, smearing_min, smearing_max = self.smearing_widget.state()
+        fp.smearing_options[fp.SMEARING_OPTION] = smearing
+        fp.smearing_options[fp.SMEARING_ACCURACY] = accuracy
+        fp.smearing_options[fp.SMEARING_MIN] = smearing_min
+        fp.smearing_options[fp.SMEARING_MAX] = smearing_max
+
+        # TODO: add polidyspersity and magnetism
+
+    def currentState(self):
+        """
+        Return fit page with current state
+        """
+        new_page = FitPage()
+        self.saveToFitPage(new_page)
+
+        return new_page
+
+    def pushFitPage(self, new_page):
+        """
+        Add a new fit page object with current state
+        """
+        #page_stack.append(new_page)
+        pass
+
+    def popFitPage(self):
+        """
+        Remove top fit page from stack
+        """
+        #if page_stack:
+        #    page_stack.pop()
+        pass
+

src/sas/qtgui/Perspectives/Fitting/SmearingWidget.py

@@ -180 +180 @@
 
         return (smearing, accuracy, d_down, d_up)
+
+    def setState(self, smearing, accuracy, d_down, d_up):
+        """
+        Sets new values for the controls
+        """
+        # Update the model -> controls update automatically
+        if smearing is not None:
+            self.model.item(MODEL.index('SMEARING')).setText(smearing)
+        if accuracy is not None:
+            self.model.item(MODEL.index('ACCURACY')).setText(accuracy)
+        if d_down is not None:
+            self.model.item(MODEL.index('PINHOLE_MIN')).setText(d_down)
+        if d_up is not None:
+            self.model.item(MODEL.index('PINHOLE_MAX')).setText(d_up)
+

src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingWidgetTest.py

@@ -301 +301 @@
         self.widget.calculateResiduals(test_data)
         # Now, the difference is non-zero
-        self.assertEqual(float(self.widget.lblChi2Value.text()), 1.715)
+        self.assertEqual(float(self.widget.lblChi2Value.text()), 1.7151)
 
     def testSetPolyModel(self):
@@ -550 +550 @@
             self.assertEqual(update_spy.count(), 1)
 
+    def testReadFitPage(self):
+        """
+        Read in the fitpage object and restore state
+        """
+        # Set data
+        test_data = Data1D(x=[1,2], y=[1,2])
+
+        # Force same data into logic
+        self.widget.logic.data = test_data
+        self.widget.data_is_loaded = True
+        category_index = self.widget.cbCategory.findText('Sphere')
+        self.widget.cbCategory.setCurrentIndex(category_index)
+        self.widget.parameters_to_fit = ['scale']
+        # Invoke the tested method
+        fp = self.widget.currentState()
+
+        # Prepare modified fit page
+        fp.current_model = 'onion'
+        fp.is_polydisperse = True
+
+        # Read in modified state
+        self.widget.readFitPage(fp)
+
+        # Check if the widget got updated accordingly
+        self.assertEqual(self.widget.cbModel.currentText(), 'onion')
+        self.assertTrue(self.widget.chkPolydispersity.isChecked())
+
+    def testCurrentState(self):
+        """
+        Set up the fitpage with current state
+        """
+        # Set data
+        test_data = Data1D(x=[1,2], y=[1,2])
+
+        # Force same data into logic
+        self.widget.logic.data = test_data
+        self.widget.data_is_loaded = True
+        category_index = self.widget.cbCategory.findText("Sphere")
+        self.widget.cbCategory.setCurrentIndex(category_index)
+        self.widget.parameters_to_fit = ['scale']
+
+        # Invoke the tested method
+        fp = self.widget.currentState()
+
+        # Test some entries. (Full testing of fp is done in FitPageTest)
+        self.assertIsInstance(fp.data, Data1D)
+        self.assertListEqual(list(fp.data.x), [1,2])
+        self.assertTrue(fp.data_is_loaded)
+        self.assertEqual(fp.current_category, "Sphere")
+        self.assertEqual(fp.current_model, "adsorbed_layer")
+        self.assertListEqual(fp.parameters_to_fit, ['scale'])
+
+    def testPushFitPage(self):
+        """
+        Push current state of fitpage onto stack
+        """
+        pass
+
+    def testPopFitPage(self):
+        """
+        Pop current state of fitpage from stack
+        """
+        pass
 
 if __name__ == "__main__":