Changeset 0315b63 in sasview for src/sas/sasgui

Timestamp:

Sep 25, 2017 5:24:46 PM (7 years ago)

Author:

Paul Kienzle <pkienzle@…>

Branches:

master, 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, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

24d9e84, fca1f50

Parents:

b277220 (diff), 66000ae (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'ticket-887-reorg' into ticket-853-fit-gui-to-calc

Location:

src/sas/sasgui

Files:

• perspectives/corfunc/corfunc_state.py (modified) (1 diff)
• perspectives/fitting/fitpage.py (modified) (1 diff)
• perspectives/fitting/simfitpage.py (modified) (3 diffs)
• perspectives/invariant/invariant_state.py (modified) (1 diff)
• perspectives/pr/inversion_state.py (modified) (1 diff)
• __init__.py (modified) (1 diff)
• guiframe/CategoryInstaller.py (modified) (5 diffs)
• guiframe/aboutbox.py (modified) (1 diff)
• guiframe/acknowledgebox.py (modified) (1 diff)
• guiframe/config.py (modified) (1 diff)
• guiframe/customdir.py (deleted)
• guiframe/data_panel.py (modified) (1 diff)
• guiframe/documentation_window.py (modified) (1 diff)
• guiframe/gui_manager.py (modified) (5 diffs)
• guiframe/local_perspectives/data_loader/data_loader.py (modified) (1 diff)
• guiframe/startup_configuration.py (modified) (2 diffs)
• perspectives/calculator/model_editor.py (modified) (10 diffs)
• perspectives/fitting/basepage.py (modified) (48 diffs)
• perspectives/fitting/batchfitpage.py (modified) (18 diffs)
• perspectives/fitting/fit_thread.py (modified) (3 diffs)
• perspectives/fitting/fitpanel.py (modified) (10 diffs)
• perspectives/fitting/fitproblem.py (modified) (40 diffs)
• perspectives/fitting/fitting.py (modified) (36 diffs)
• perspectives/fitting/model_thread.py (modified) (10 diffs)
• perspectives/fitting/models.py (deleted)
• perspectives/fitting/report_dialog.py (modified) (3 diffs)

src/sas/sasgui/perspectives/corfunc/corfunc_state.py

@@ -289 +289 @@
                 namespaces={'ns': CANSAS_NS})
             for entry in entry_list:
-                sas_entry, _ = self._parse_entry(entry)
                 corstate = self._parse_state(entry)
 
                 if corstate is not None:
+                    sas_entry, _ = self._parse_entry(entry)
                     sas_entry.meta_data['corstate'] = corstate
                     sas_entry.filename = corstate.file

src/sas/sasgui/perspectives/fitting/fitpage.py

@@ -2049 +2049 @@
             # Save state_fit
             self.save_current_state_fit()
+            self.onSmear(None)
+            self._onDraw(None)
         except:
             self._show_combox_helper()

src/sas/sasgui/perspectives/fitting/simfitpage.py

@@ -163 +163 @@
         :return: None
         """
-        model_map = {}
+        init_map = {}
+        final_map = {}
         # Process each model and associate old M# with new M#
         i = 0
@@ -175 +176 @@
                     model_map[saved_model.pop('fit_page_source')] = \
                         model[3].name
+                    check = bool(saved_model.pop('checked'))
+                    self.model_list[i][0].SetValue(check)
+                    inter_id = str(i)*5
+                    init_map[saved_model.pop('fit_page_source')] = inter_id
+                    final_map[inter_id] = model[3].name
                     check = bool(saved_model.pop('checked'))
                     self.model_list[i][0].SetValue(check)
@@ -1099 +1105 @@
         cbox.Append(name, value)
     cbox.SetStringSelection(selected)
+<<<<<<< HEAD
+=======
+
+
+class SimFitPageState:
+    """
+    State of the simultaneous fit page for saving purposes
+    """
+
+    def __init__(self):
+        # Sim Fit Page Number
+        self.fit_page_no = None
+        # Select all data
+        self.select_all = False
+        # Data sets sent to fit page
+        self.model_list = []
+        # Data sets to be fit
+        self.model_to_fit = []
+        # Number of constraints
+        self.no_constraint = 0
+        # Dictionary of constraints
+        self.constraint_dict = {}
+        # List of constraints
+        self.constraints_list = []
+
+    def load_from_save_state(self, fit):
+        """
+        Load in a simultaneous/constrained fit from a save state
+        :param fit: Fitpanel object
+        :return: None
+        """
+
+        init_map = {}
+        final_map = {}
+        if fit.fit_panel.sim_page is None:
+            fit.fit_panel.add_sim_page()
+        sim_page = fit.fit_panel.sim_page
+
+        # Process each model and associate old M# with new M#
+        i = 0
+        for model in sim_page.model_list:
+            model_id = self._format_id(model[1].keys()[0])
+            for saved_model in self.model_list:
+                save_id = saved_model.pop('name')
+                saved_model['name'] = save_id
+                save_id = self._format_id(save_id)
+                if save_id == model_id:
+                    inter_id = str(i) + str(i) + str(i) + str(i) + str(i)
+                    init_map[saved_model.pop('fit_page_source')] = inter_id
+                    final_map[inter_id] = model[3].name
+                    check = bool(saved_model.pop('checked'))
+                    sim_page.model_list[i][0].SetValue(check)
+                    break
+            i += 1
+        sim_page.check_model_name(None)
+
+        if len(self.constraints_list) > 0:
+            sim_page.hide_constraint.SetValue(False)
+            sim_page.show_constraint.SetValue(True)
+            sim_page._display_constraint(None)
+
+        for index, item in enumerate(self.constraints_list):
+            model_cbox = item.pop('model_cbox')
+            if model_cbox != "":
+                constraint_value = item.pop('constraint')
+                param = item.pop('param_cbox')
+                equality = item.pop('egal_txt')
+                for key, value in init_map.items():
+                    model_cbox = model_cbox.replace(key, value)
+                    constraint_value = constraint_value.replace(key, value)
+                for key, value in final_map.items():
+                    model_cbox = model_cbox.replace(key, value)
+                    constraint_value = constraint_value.replace(key, value)
+
+                sim_page.constraints_list[index][0].SetValue(model_cbox)
+                sim_page._on_select_model(None)
+                sim_page.constraints_list[index][1].SetValue(param)
+                sim_page.constraints_list[index][2].SetLabel(equality)
+                sim_page.constraints_list[index][3].SetValue(constraint_value)
+                sim_page._on_add_constraint(None)
+                sim_page._manager.sim_page = sim_page
+
+    def _format_id(self, original_id):
+        original_id = original_id.rstrip('1234567890.')
+        new_id_list = original_id.split()
+        new_id = ' '.join(new_id_list)
+        return new_id
+>>>>>>> ticket-887-reorg

src/sas/sasgui/perspectives/invariant/invariant_state.py

@@ -728 +728 @@
 
                 for entry in entry_list:
-
-                    sas_entry, _ = self._parse_entry(entry)
                     invstate = self._parse_state(entry)
-
                     # invstate could be None when .svs file is loaded
                     # in this case, skip appending to output
                     if invstate is not None:
+                        sas_entry, _ = self._parse_entry(entry)
                         sas_entry.meta_data['invstate'] = invstate
                         sas_entry.filename = invstate.file

src/sas/sasgui/perspectives/pr/inversion_state.py

@@ -472 +472 @@
 
                 for entry in entry_list:
-                    sas_entry, _ = self._parse_entry(entry)
                     prstate = self._parse_prstate(entry)
                     #prstate could be None when .svs file is loaded
                     #in this case, skip appending to output
                     if prstate is not None:
+                        sas_entry, _ = self._parse_entry(entry)
                         sas_entry.meta_data['prstate'] = prstate
                         sas_entry.filename = prstate.file

src/sas/sasgui/__init__.py

@@ -1 @@
-import sys
-import os
-from os.path import exists, expanduser, dirname, realpath, join as joinpath
-
-
-def dirn(path, n):
-    path = realpath(path)
-    for _ in range(n):
-        path = dirname(path)
-    return path
-
-# Set up config directories
-def make_user_folder():
-    path = joinpath(expanduser("~"),'.sasview')
-    if not exists(path):
-        os.mkdir(path)
-    return path
-
-
-def find_app_folder():
-    # We are starting out with the following info:
-    #     __file__ = .../sas/sasgui/__init__.pyc
-    # Check if the sister path .../sas/sasview exists, and use it as the
-    # app directory.  This will only be the case if the app is not frozen.
-    path = joinpath(dirn(__file__, 2), 'sasview')
-    if exists(path):
-        return path
-
-    # If we are running frozen, then root is a parent directory
-    if sys.platform == 'darwin':
-        # Here is the path to the file on the mac:
-        #     .../Sasview.app/Contents/Resources/lib/python2.7/site-packages.zip/sas/sasgui/__init__.pyc
-        # We want the path to the Resources directory.
-        path = dirn(__file__, 6)
-    elif os.name == 'nt':
-        # Here is the path to the file on windows:
-        #     ../Sasview/library.zip/sas/sasgui/__init__.pyc
-        # We want the path to the Sasview directory.
-        path = dirn(__file__, 4)
-    else:
-        raise RuntimeError("Couldn't find the app directory")
-    return path
-
-USER_FOLDER = make_user_folder()
-APP_FOLDER = find_app_folder()
-
-
-def get_app_dir():
-    return APP_FOLDER
-
-def get_user_dir():
-    return USER_FOLDER
-
-def get_custom_config_path():
-    dirname = os.path.join(get_user_dir(), 'config')
-    # If the directory doesn't exist, create it
-    if not os.path.exists(dirname):
-        os.makedirs(dirname)
-    path = os.path.join(dirname, "custom_config.py")
-    return path
-
-_config_cache = None
-def get_local_config():
-    global _config_cache
-    if not _config_cache:
-        _config_cache = _load_config()
-    return _config_cache
-
-def _load_config():
-    import os
-    import sys
-    import logging
-    from sasmodels.custom import load_module_from_path
-
-    logger = logging.getLogger(__name__)
-    dirname = get_app_dir()
-    filename = 'local_config.py'
-    path = os.path.join(dirname, filename)
-    try:
-        module = load_module_from_path('sas.sasgui.local_config', path)
-        logger.info("GuiManager loaded %s", path)
-        return module
-    except Exception as exc:
-        logger.critical("Error loading %s: %s", path, exc)
-        sys.exit()

src/sas/sasgui/guiframe/CategoryInstaller.py

@@ -15 +15 @@
 from collections import defaultdict, OrderedDict
 
-from sas.sasgui import get_user_dir
+from sas import get_user_dir
 
 USER_FILE = 'categories.json'
@@ -27 +27 @@
     Note - class is entirely static!
     """
+
+    @staticmethod
+    def _get_installed_model_dir():
+        """
+        returns the dir where installed_models.txt should be
+        """
+        from sas.sascalc.dataloader.readers import get_data_path
+        return get_data_path()
+
+    @staticmethod
+    def _get_default_cat_file_dir():
+        """
+        returns the dir where default_cat.j should be
+        """
+        # The default categories file is usually found with the code, except
+        # when deploying using py2app (it will be in Contents/Resources), or
+        # py2exe (it will be in the exec dir).
+        import sas.sasview
+        cat_file = "default_categories.json"
+
+        possible_cat_file_paths = [
+            os.path.join(os.path.split(sas.sasview.__file__)[0], cat_file),           # Source
+            os.path.join(os.path.dirname(sys.executable), '..', 'Resources', cat_file), # Mac
+            os.path.join(os.path.dirname(sys.executable), cat_file)                     # Windows
+        ]
+
+        for path in possible_cat_file_paths:
+            if os.path.isfile(path):
+                return os.path.dirname(path)
+
+        raise RuntimeError('CategoryInstaller: Could not find folder containing default categories')
+
+    @staticmethod
+    def _get_home_dir():
+        """
+        returns the users sasview config dir
+        """
+        return os.path.join(os.path.expanduser("~"), ".sasview")
 
     @staticmethod
@@ -81 +119 @@
                which are user supplied.
         """
-        _model_dict = { model.name: model for model in model_list}
+        _model_dict = {model.name: model for model in model_list}
         _model_list = _model_dict.keys()
 
@@ -107 +145 @@
                         by_model_dict.pop(model_name)
                         model_enabled_dict.pop(model_name)
-                    except:
+                    except Exception:
                         logger.error("CategoryInstaller: %s", sys.exc_value)
                 else:
@@ -113 +151 @@
         if del_name or (len(add_list) > 0):
             for model in add_list:
-                model_enabled_dict[model]= True
-                if _model_dict[model].category is None or len(str(_model_dict[model].category.capitalize())) == 0:
+                model_enabled_dict[model] = True
+                # TODO: should be:  not _model_dict[model].category
+                if (_model_dict[model].category is None
+                        or len(str(_model_dict[model].category.capitalize())) == 0):
                     by_model_dict[model].append('Uncategorized')
                 else:

src/sas/sasgui/guiframe/aboutbox.py

@@ -25 +25 @@
 import os
 
-from sas.sasgui import get_local_config
+from sas import get_local_config
 config = get_local_config()
 

src/sas/sasgui/guiframe/acknowledgebox.py

@@ -13 +13 @@
 from wx.lib.expando import ExpandoTextCtrl
 
-from sas.sasgui import get_local_config
+from sas import get_local_config
 config = get_local_config()
 

src/sas/sasgui/guiframe/config.py

@@ -145 +145 @@
 UPDATE_TIMEOUT = 2
 
-#OpenCL option
-SAS_OPENCL = None
-
 # Time out for updating sasview
 UPDATE_TIMEOUT = 2

src/sas/sasgui/guiframe/data_panel.py

@@ -33 +33 @@
 from sas.sasgui.guiframe.local_perspectives.plotting.SimplePlot \
     import PlotFrame as QucikPlotDialog
-from sas.sasgui import get_local_config
+from sas import get_local_config
 
 config = get_local_config()

src/sas/sasgui/guiframe/documentation_window.py

@@ -27 +27 @@
     WX_SUPPORTS_HTML2 = False
 
-from sas.sasgui import get_app_dir
+from sas import get_app_dir
 
 # Don't use wx html renderer on windows.

src/sas/sasgui/guiframe/gui_manager.py

@@ -28 +28 @@
 from matplotlib import _pylab_helpers
 
-from sas.sasgui import get_local_config, get_app_dir, get_user_dir
+from sas import get_local_config, get_custom_config, get_app_dir, get_user_dir
 from sas.sasgui.guiframe.events import EVT_CATEGORY
 from sas.sasgui.guiframe.events import EVT_STATUS
@@ -47 +47 @@
 from sas.sascalc.dataloader.loader import Loader
 from sas.sasgui.guiframe.proxy import Connection
-from sas.sasgui.guiframe.customdir import setup_custom_config
 
 logger = logging.getLogger(__name__)
@@ -53 +52 @@
 
 config = get_local_config()
-custom_config = setup_custom_config()
+custom_config = get_custom_config()
 
 # read some constants from config
@@ -63 +62 @@
 SPLASH_SCREEN_HEIGHT = config.SPLASH_SCREEN_HEIGHT
 SS_MAX_DISPLAY_TIME = config.SS_MAX_DISPLAY_TIME
-SAS_OPENCL = config.SAS_OPENCL
 if not WELCOME_PANEL_ON:
     WELCOME_PANEL_SHOW = False
@@ -138 +136 @@
         PARENT_FRAME = wx.Frame
         CHILD_FRAME = wx.Frame
-
-#Initiliaze enviromental variable with custom setting but only if variable not set
-if SAS_OPENCL and not "SAS_OPENCL" in os.environ:
-    os.environ["SAS_OPENCL"] = SAS_OPENCL
 
 class ViewerFrame(PARENT_FRAME):

src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

@@ -10 +10 @@
 logger = logging.getLogger(__name__)
 
+from sas import get_local_config
+
 from sas.sascalc.dataloader.loader import Loader
 from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException
 
-from sas.sasgui import get_local_config
 from sas.sasgui.guiframe.plugin_base import PluginBase
 from sas.sasgui.guiframe.events import StatusEvent

src/sas/sasgui/guiframe/startup_configuration.py

@@ -13 +13 @@
 import wx
 
-from sas.sasgui import get_custom_config_path
+from sas import make_custom_config_path
 from sas.sasgui.guiframe.events import StatusEvent
 from sas.sasgui.guiframe.gui_style import GUIFRAME
@@ -194 +194 @@
         Write custom configuration
         """
-        path = get_custom_config_path()
+        path = make_custom_config_path()
         with open(path, 'w') as out_f:
             out_f.write("#Application appearance custom configuration\n")

src/sas/sasgui/perspectives/calculator/model_editor.py

@@ -31 +31 @@
 import re
 import logging
+import datetime
+
 from wx.py.editwindow import EditWindow
+
 from sas.sasgui.guiframe.documentation_window import DocumentationWindow
+
 from .pyconsole import show_model_output, check_model
 
 logger = logging.getLogger(__name__)
-
 
 if sys.platform.count("win32") > 0:
@@ -78 +81 @@
     a Modal Dialog.
 
-    :TODO the build in compiler currently balks at when it tries to import
+    :TODO the built in compiler currently balks at when it tries to import
     a model whose name contains spaces or symbols (such as + ... underscore
     should be fine).  Have fixed so the editor cannot save such a file name
@@ -335 +338 @@
             list_fnames = os.listdir(self.plugin_dir)
             # fake existing regular model name list
-            m_list = [model + ".py" for model in self.model_list]
+            m_list = [model.name + ".py" for model in self.model_list]
             list_fnames.append(m_list)
             if t_fname in list_fnames and title != mname:
@@ -533 +536 @@
             desc_line = "\nmodel_info.description = '{}'".format(description)
         name = os.path.splitext(os.path.basename(self.fname))[0]
-        output = SUM_TEMPLATE.format(name=name, model1=model1_name, 
+        output = SUM_TEMPLATE.format(name=name, model1=model1_name,
             model2=model2_name, operator=self._operator, desc_line=desc_line)
         with open(self.fname, 'w') as out_f:
@@ -789 +792 @@
                     exec "float(math.%s)" % item
                     self.math_combo.Append(str(item))
-                except:
+                except Exception:
                     self.math_combo.Append(str(item) + "()")
         self.math_combo.Bind(wx.EVT_COMBOBOX, self._on_math_select)
@@ -914 +917 @@
             msg = "Name exists already."
 
-        # Prepare the messagebox
+        #
         if self.base is not None and not msg:
             self.base.update_custom_combo()
-            # Passed exception in import test as it will fail for sasmodels.sasview_model class
-            # Should add similar test for new style?
-            Model = None
-            try:
-                exec "from %s import Model" % name
-            except:
-                logger.error(sys.exc_value)
 
         # Prepare the messagebox
@@ -956 +952 @@
         :param func_str: content of func; Strings
         """
-        try:
-            out_f = open(fname, 'w')
-        except:
-            raise
-        # Prepare the content of the function
-        lines = CUSTOM_TEMPLATE.split('\n')
-
-        has_scipy = func_str.count("scipy.")
-        if has_scipy:
-            lines.insert(0, 'import scipy')
-
-        # Think about 2D later
-        #self.is_2d = func_str.count("#self.ndim = 2")
-        #line_2d = ''
-        #if self.is_2d:
-        #    line_2d = CUSTOM_2D_TEMP.split('\n')
-
-        # Also think about test later
-        #line_test = TEST_TEMPLATE.split('\n')
-        #local_params = ''
-        #spaces = '        '#8spaces
-        spaces4  = ' '*4
-        spaces13 = ' '*13
-        spaces16 = ' '*16
+        out_f = open(fname, 'w')
+
+        out_f.write(CUSTOM_TEMPLATE % {
+            'name': name,
+            'title': 'User model for ' + name,
+            'description': desc_str,
+            'date': datetime.datetime.now().strftime('%YYYY-%mm-%dd'),
+        })
+
+        # Write out parameters
         param_names = []    # to store parameter names
-        has_scipy = func_str.count("scipy.")
-        if has_scipy:
-            lines.insert(0, 'import scipy')
-
-        # write function here
-        for line in lines:
-            # The location where to put the strings is
-            # hard-coded in the template as shown below.
-            out_f.write(line + '\n')
-            if line.count('#name'):
-                out_f.write('name = "%s" \n' % name)
-            elif line.count('#title'):
-                out_f.write('title = "User model for %s"\n' % name)
-            elif line.count('#description'):
-                out_f.write('description = "%s"\n' % desc_str)
-            elif line.count('#parameters'):
-                out_f.write('parameters = [ \n')
-                for param_line in param_str.split('\n'):
-                    p_line = param_line.lstrip().rstrip()
-                    if p_line:
-                        pname, pvalue, desc = self.get_param_helper(p_line)
-                        param_names.append(pname)
-                        out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', '%s'],\n" % (spaces16, pname, pvalue, desc))
-                for param_line in pd_param_str.split('\n'):
-                    p_line = param_line.lstrip().rstrip()
-                    if p_line:
-                        pname, pvalue, desc = self.get_param_helper(p_line)
-                        param_names.append(pname)
-                        out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', '%s'],\n" % (spaces16, pname, pvalue, desc))
-                out_f.write('%s]\n' % spaces13)
-
-        # No form_volume or ER available in simple model editor
-        out_f.write('def form_volume(*arg): \n')
-        out_f.write('    return 1.0 \n')
-        out_f.write('\n')
-        out_f.write('def ER(*arg): \n')
-        out_f.write('    return 1.0 \n')
-
-        # function to compute
-        out_f.write('\n')
-        out_f.write('def Iq(x ')
-        for name in param_names:
-            out_f.write(', %s' % name)
-        out_f.write('):\n')
+        pd_params = []
+        out_f.write('parameters = [ \n')
+        out_f.write('#   ["name", "units", default, [lower, upper], "type", "description"],\n')
+        for pname, pvalue, desc in self.get_param_helper(param_str):
+            param_names.append(pname)
+            out_f.write("    ['%s', '', %s, [-inf, inf], '', '%s'],\n"
+                        % (pname, pvalue, desc))
+        for pname, pvalue, desc in self.get_param_helper(pd_param_str):
+            param_names.append(pname)
+            pd_params.append(pname)
+            out_f.write("    ['%s', '', %s, [-inf, inf], 'volume', '%s'],\n"
+                        % (pname, pvalue, desc))
+        out_f.write('    ]\n')
+
+        # Write out function definition
+        out_f.write('def Iq(%s):\n' % ', '.join(['x'] + param_names))
+        out_f.write('    """Absolute scattering"""\n')
+        if "scipy." in func_str:
+            out_f.write('    import scipy')
+        if "numpy." in func_str:
+            out_f.write('    import numpy')
+        if "np." in func_str:
+            out_f.write('    import numpy as np')
         for func_line in func_str.split('\n'):
             out_f.write('%s%s\n' % (spaces4, func_line))
-
-        Iqxy_string = 'return Iq(numpy.sqrt(x**2+y**2) '
-
+        out_f.write('## uncomment the following if Iq works for vector x\n')
+        out_f.write('#Iq.vectorized = True\n')
+
+        # If polydisperse, create place holders for form_volume, ER and VR
+        if pd_params:
+            out_f.write('\n')
+            out_f.write(CUSTOM_TEMPLATE_PD % {'args': ', '.join(pd_params)})
+
+        # Create place holder for Iqxy
         out_f.write('\n')
-        out_f.write('def Iqxy(x, y ')
-        for name in param_names:
-            out_f.write(', %s' % name)
-            Iqxy_string += ', ' + name
-        out_f.write('):\n')
-        Iqxy_string += ')'
-        out_f.write('%s%s\n' % (spaces4, Iqxy_string))
+        out_f.write('#def Iqxy(%s):\n' % ', '.join(["x", "y"] + param_names))
+        out_f.write('#    """Absolute scattering of oriented particles."""\n')
+        out_f.write('#    ...\n')
+        out_f.write('#    return oriented_form(x, y, args)\n')
+        out_f.write('## uncomment the following if Iqxy works for vector x, y\n')
+        out_f.write('#Iqxy.vectorized = True\n')
 
         out_f.close()
 
-    def get_param_helper(self, line):
-        """
-        Get string in line to define the params dictionary
-
-        :param line: one line of string got from the param_str
-        """
-        items = line.split(";")
-        for item in items:
-            name = item.split("=")[0].strip()
-            description = ""
-            try:
-                value = item.split("=")[1].strip()
-                if value.count("#"):
-                    # If line ends in a comment, remove it before parsing float
-                    index = value.index("#")
-                    description = value[(index + 1):].strip()
-                    value = value[:value.index("#")].strip()
-                float(value)
-            except ValueError:
-                value = 1.0 # default
-
-        return name, value, description
+    def get_param_helper(self, param_str):
+        """
+        yield a sequence of name, value pairs for the parameters in param_str
+
+        Parameters can be defined by one per line by name=value, or multiple
+        on the same line by separating the pairs by semicolon or comma.  The
+        value is optional and defaults to "1.0".
+        """
+        for line in param_str.replace(';', ',').split('\n'):
+            for item in line.split(','):
+                defn, desc = item.split('#', 1) if '#' in item else (item, '')
+                name, value = defn.split('=', 1) if '=' in defn else (defn, '1.0')
+                if name:
+                    yield [v.strip() for v in (name, value, desc)]
 
     def set_function_helper(self, line):
@@ -1096 +1054 @@
         running "file:///...."
 
-    :param evt: Triggers on clicking the help button
-    """
+        :param evt: Triggers on clicking the help button
+        """
 
         _TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html"
@@ -1140 +1098 @@
 ## Templates for plugin models
 
-CUSTOM_TEMPLATE = """
+CUSTOM_TEMPLATE = '''\
+r"""
+Definition
+----------
+
+Calculates %(name)s.
+
+%(description)s
+
+References
+----------
+
+Authorship and Verification
+---------------------------
+
+* **Author:** --- **Date:** %(date)s
+* **Last Modified by:** --- **Date:** %(date)s
+* **Last Reviewed by:** --- **Date:** %(date)s
+"""
+
 from math import *
-import os
-import sys
-import numpy
-
-#name
-
-#title
-
-#description
-
-#parameters
-
-"""
-
-CUSTOM_2D_TEMP = """
-    def run(self, x=0.0, y=0.0):
-        if x.__class__.__name__ == 'list':
-            x_val = x[0]
-            y_val = y[0]*0.0
-            return self.function(x_val, y_val)
-        elif x.__class__.__name__ == 'tuple':
-            msg = "Tuples are not allowed as input to BaseComponent models"
-            raise ValueError, msg
-        else:
-            return self.function(x, 0.0)
-    def runXY(self, x=0.0, y=0.0):
-        if x.__class__.__name__ == 'list':
-            return self.function(x, y)
-        elif x.__class__.__name__ == 'tuple':
-            msg = "Tuples are not allowed as input to BaseComponent models"
-            raise ValueError, msg
-        else:
-            return self.function(x, y)
-    def evalDistribution(self, qdist):
-        if qdist.__class__.__name__ == 'list':
-            msg = "evalDistribution expects a list of 2 ndarrays"
-            if len(qdist)!=2:
-                raise RuntimeError, msg
-            if qdist[0].__class__.__name__ != 'ndarray':
-                raise RuntimeError, msg
-            if qdist[1].__class__.__name__ != 'ndarray':
-                raise RuntimeError, msg
-            v_model = numpy.vectorize(self.runXY, otypes=[float])
-            iq_array = v_model(qdist[0], qdist[1])
-            return iq_array
-        elif qdist.__class__.__name__ == 'ndarray':
-            v_model = numpy.vectorize(self.runXY, otypes=[float])
-            iq_array = v_model(qdist)
-            return iq_array
-"""
-TEST_TEMPLATE = """
-######################################################################
-## THIS IS FOR TEST. DO NOT MODIFY THE FOLLOWING LINES!!!!!!!!!!!!!!!!
-if __name__ == "__main__":
-    m= Model()
-    out1 = m.runXY(0.0)
-    out2 = m.runXY(0.01)
-    isfine1 = numpy.isfinite(out1)
-    isfine2 = numpy.isfinite(out2)
-    print "Testing the value at Q = 0.0:"
-    print out1, " : finite? ", isfine1
-    print "Testing the value at Q = 0.01:"
-    print out2, " : finite? ", isfine2
-    if isfine1 and isfine2:
-        print "===> Simple Test: Passed!"
-    else:
-        print "===> Simple Test: Failed!"
-"""
+from numpy import inf
+
+name = "%(name)s"
+title = "%(title)s"
+description = """%(description)s"""
+
+'''
+
+CUSTOM_TEMPLATE_PD = '''\
+def form_volume(%(args)s):
+    """
+    Volume of the particles used to compute absolute scattering intensity
+    and to weight polydisperse parameter contributions.
+    """
+    return 0.0
+
+def ER(%(args)s):
+    """
+    Effective radius of particles to be used when computing structure factors.
+
+    Input parameters are vectors ranging over the mesh of polydispersity values.
+    """
+    return 0.0
+
+def VR(%(args)s):
+    """
+    Volume ratio of particles to be used when computing structure factors.
+
+    Input parameters are vectors ranging over the mesh of polydispersity values.
+    """
+    return 1.0
+'''
+
 SUM_TEMPLATE = """
 from sasmodels.core import load_model_info
@@ -1219 +1161 @@
 """
 if __name__ == "__main__":
-#    app = wx.PySimpleApp()
     main_app = wx.App()
     main_frame = TextDialog(id=1, model_list=["SphereModel", "CylinderModel"],
-                       plugin_dir='../fitting/plugin_models')
+                            plugin_dir='../fitting/plugin_models')
     main_frame.ShowModal()
     main_app.MainLoop()
-
-#if __name__ == "__main__":
-#    from sas.sasgui.perspectives.fitting import models
-#    dir_path = models.find_plugins_dir()
-#    app = wx.App()
-#    window = EditorWindow(parent=None, base=None, path=dir_path, title="Editor")
-#    app.MainLoop()

src/sas/sasgui/perspectives/fitting/basepage.py

@@ -6 +6 @@
 import sys
 import os
-import wx
-import numpy as np
 import time
 import copy
@@ -14 +12 @@
 import logging
 import traceback
-
 from Queue import Queue
 from threading import Thread
 from collections import defaultdict
+
+import numpy as np
+
+import wx
 from wx.lib.scrolledpanel import ScrolledPanel
 
+from sasmodels.sasview_model import MultiplicationModel
 from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
+from sasmodels.weights import GaussianDispersion
+
+from sas.sascalc.dataloader.data_info import Detector
+from sas.sascalc.dataloader.data_info import Source
+from sas.sascalc.fit.pagestate import PageState
+from sas.sascalc.fit.models import PLUGIN_NAME_BASE
 
 from sas.sasgui.guiframe.panel_base import PanelBase
@@ -32 +40 @@
 from sas.sasgui.guiframe.dataFitting import check_data_validity
 from sas.sasgui.guiframe.gui_style import GUIFRAME_ID
-from sas.sascalc.dataloader.data_info import Detector
-from sas.sascalc.dataloader.data_info import Source
-from sas.sasgui.perspectives.fitting.pagestate import PageState
 from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller
 from sas.sasgui.guiframe.documentation_window import DocumentationWindow
+
+from .report_dialog import ReportDialog
+from .utils import get_weight
 
 logger = logging.getLogger(__name__)
@@ -155 +163 @@
         self.disp_cb_dict = {}
 
-        # self.state = PageState(parent=parent)
+        # self.state = PageState()
         # dictionary containing list of models
         self.model_list_box = {}
@@ -202 +210 @@
         self.fitrange = True
         # Create memento to save the current state
-        self.state = PageState(parent=self.parent,
-                               model=self.model, data=self.data)
+        self.state = PageState(model=self.model, data=self.data)
         # flag to determine if state has change
         self.state_change = False
@@ -295 +302 @@
         """
         x = np.linspace(start=self.qmin_x, stop=self.qmax_x,
-                           num=self.npts_x, endpoint=True)
+                        num=self.npts_x, endpoint=True)
         self.data = Data1D(x=x)
         self.data.xaxis('\\rm{Q}', "A^{-1}")
@@ -321 +328 @@
 
         x = np.logspace(start=qmin, stop=qmax,
-                           num=self.npts_x, endpoint=True, base=10.0)
+                        num=self.npts_x, endpoint=True, base=10.0)
         self.data = Data1D(x=x)
         self.data.xaxis('\\rm{Q}', "A^{-1}")
@@ -510 +517 @@
         self.state.manager = manager
 
-    def populate_box(self, model_dict):
+    def populate_box(self, model_list_box):
         """
         Store list of model
 
-        :param model_dict: dictionary containing list of models
-
-        """
-        self.model_list_box = model_dict
-        self.state.model_list_box = self.model_list_box
+        :param model_list_box: dictionary containing categorized models
+        """
+        self.model_list_box = model_list_box
         self.initialize_combox()
 
-    def set_model_dictionary(self, model_dict):
+    def set_model_dictionary(self, model_dictionary):
         """
         Store a dictionary linking model name -> model object
 
-        :param model_dict: dictionary containing list of models
-        """
-        self.model_dict = model_dict
+        :param model_dictionary: dictionary containing all models
+        """
+        self.model_dictionary = model_dictionary
 
     def initialize_combox(self):
@@ -533 +538 @@
         put default value in the combo box
         """
-        if self.model_list_box is not None and len(self.model_list_box) > 0:
+        if self.model_list_box:
             self._populate_box(self.structurebox,
                                self.model_list_box["Structure Factors"])
@@ -632 +637 @@
         # Get plot image from plotpanel
         images, canvases = self.get_images()
-        # get the report dialog
-        self.state.report(images, canvases)
+        imgRAM, images, refs = self._build_plots_for_report(images, canvases)
+
+        # get the strings for report
+        report_str, text_str = self.state.report(fig_urls=refs)
+
+        # Show the dialog
+        report_list = [report_str, text_str, images]
+        dialog = ReportDialog(report_list, None, wx.ID_ANY, "")
+        dialog.Show()
+
+    def _build_plots_for_report(self, figs, canvases):
+        """
+        Build image state that wx.html understand
+        by plotting, putting it into wx.FileSystem image object
+        """
+        images = []
+        refs = []
+
+        # For no figures in the list, prepare empty plot
+        if figs is None or len(figs) == 0:
+            figs = [None]
+
+        # Loop over the list of figures
+        # use wx.MemoryFSHandler
+        imgRAM = wx.MemoryFSHandler()
+        for fig in figs:
+            if fig is not None:
+                ind = figs.index(fig)
+                canvas = canvases[ind]
+
+            # store the image in wx.FileSystem Object
+            wx.FileSystem.AddHandler(wx.MemoryFSHandler())
+
+            # index of the fig
+            ind = figs.index(fig)
+
+            # AddFile, image can be retrieved with 'memory:filename'
+            name = 'img_fit%s.png' % ind
+            refs.append('memory:' + name)
+            imgRAM.AddFile(name, canvas.bitmap, wx.BITMAP_TYPE_PNG)
+
+            # append figs
+            images.append(fig)
+
+        return imgRAM, images, refs
+
 
     def on_save(self, event):
@@ -855 +904 @@
             self.state.disable_disp = self.disable_disp.GetValue()
 
-        self.state.smearer = copy.deepcopy(self.current_smearer)
         if hasattr(self, "enable_smearer"):
             self.state.enable_smearer = \
@@ -871 +919 @@
         if len(self._disp_obj_dict) > 0:
             for k, v in self._disp_obj_dict.iteritems():
-                self.state._disp_obj_dict[k] = v.type
+                self.state.disp_obj_dict[k] = v.type
 
             self.state.values = copy.deepcopy(self.values)
@@ -889 +937 @@
                                     self.state.str_parameters)
         self._copy_parameters_state(self.orientation_params,
-                                     self.state.orientation_params)
+                                    self.state.orientation_params)
         self._copy_parameters_state(self.orientation_params_disp,
                                     self.state.orientation_params_disp)
@@ -920 +968 @@
             self.state.disable_disp = self.disable_disp.GetValue()
 
-        self.state.smearer = copy.deepcopy(self.current_smearer)
         if hasattr(self, "enable_smearer"):
             self.state.enable_smearer = \
@@ -944 +991 @@
                         try:
                             self.state.disp_cb_dict[k] = v.GetValue()
-                        except:
+                        except Exception:
                             self.state.disp_cb_dict[k] = None
             if len(self._disp_obj_dict) > 0:
                 for k, v in self._disp_obj_dict.iteritems():
-                    self.state._disp_obj_dict[k] = v.type
+                    self.state.disp_obj_dict[k] = v.type
 
             self.state.values = copy.deepcopy(self.values)
@@ -990 +1037 @@
             # to support older version
             category_pos = int(state.categorycombobox)
-        except:
+        except Exception:
             category_pos = 0
             for ind_cat in range(self.categorybox.GetCount()):
@@ -1002 +1049 @@
             # to support older version
             formfactor_pos = int(state.formfactorcombobox)
-        except:
+        except Exception:
             formfactor_pos = 0
             for ind_form in range(self.formfactorbox.GetCount()):
@@ -1015 +1062 @@
             # to support older version
             structfactor_pos = int(state.structurecombobox)
-        except:
+        except Exception:
             structfactor_pos = 0
             for ind_struct in range(self.structurebox.GetCount()):
@@ -1182 +1229 @@
         self.categorybox.Select(category_pos)
         self._show_combox(None)
-        from models import PLUGIN_NAME_BASE
-        if self.categorybox.GetValue() == CUSTOM_MODEL \
-                and PLUGIN_NAME_BASE not in state.formfactorcombobox:
+        if (self.categorybox.GetValue() == CUSTOM_MODEL
+                and PLUGIN_NAME_BASE not in state.formfactorcombobox):
             state.formfactorcombobox = \
                 PLUGIN_NAME_BASE + state.formfactorcombobox
         formfactor_pos = 0
         for ind_form in range(self.formfactorbox.GetCount()):
-            if self.formfactorbox.GetString(ind_form) == \
-                                                (state.formfactorcombobox):
+            if (self.formfactorbox.GetString(ind_form)
+                    == state.formfactorcombobox):
                 formfactor_pos = int(ind_form)
                 break
@@ -1200 +1246 @@
             state.structurecombobox = unicode(state.structurecombobox)
             for ind_struct in range(self.structurebox.GetCount()):
-                if self.structurebox.GetString(ind_struct) == \
-                                                (state.structurecombobox):
+                if (self.structurebox.GetString(ind_struct)
+                        == state.structurecombobox):
                     structfactor_pos = int(ind_struct)
                     break
@@ -1252 +1298 @@
             self.dI_sqrdata.SetValue(state.dI_sqrdata)
             self.dI_idata.SetValue(state.dI_idata)
-        except:
+        except Exception:
             # to support older state file formats
             self.dI_noweight.SetValue(False)
@@ -1308 +1354 @@
         self.weights = copy.deepcopy(state.weights)
 
-        for key, disp_type in state._disp_obj_dict.iteritems():
+        for key, disp_type in state.disp_obj_dict.iteritems():
             # disp_model = disp
             disp_model = POLYDISPERSITY_MODELS[disp_type]()
@@ -1542 +1588 @@
                         try:
                             self.npts_x = float(self.Npts_total.GetValue())
-                        except:
+                        except Exception:
                             flag = False
                             return flag
@@ -1583 +1629 @@
             return
 
-        for j in range(len(listtorestore)):
+        for item_page in listtorestore:
             for param in statelist:
-                if param[1] == listtorestore[j][1]:
-                    item_page = listtorestore[j]
+                if param[1] == item_page[1]:
                     item_page_info = param
                     if (item_page_info[1] == "theta" or item_page_info[1] ==
@@ -1632 +1677 @@
         listtorestore = copy.deepcopy(statelist)
 
-        for j in range(len(listtorestore)):
-            item_page = listtorestore[j]
-            item_page_info = statelist[j]
+        for item_page, item_page_info in zip(listtorestore, statelist):
             # change the state of the check box for simple parameters
-
             if item_page[0] is not None:
                 item_page[0].SetValue(format_number(item_page_info[0], True))
@@ -1741 +1783 @@
                     temp_smear = self.current_smearer
             # compute weight for the current data
-            from sas.sasgui.perspectives.fitting.utils import get_weight
             flag = self.get_weight_flag()
             weight = get_weight(data=self.data, is2d=self._is_2D(), flag=flag)
@@ -1768 +1809 @@
 
         from sas.sasgui.plottools import Data1D as pf_data1d
-        # from sas.sasgui.perspectives.theory.profile_dialog import SLDPanel
         from sas.sasgui.guiframe.local_perspectives.plotting.profile_dialog \
             import SLDPanel
@@ -1829 +1869 @@
             if mod_cat == CUSTOM_MODEL:
                 for model in self.model_list_box[mod_cat]:
-                    m_list.append(self.model_dict[model.name])
+                    m_list.append(self.model_dictionary[model.name])
             else:
                 cat_dic = self.master_category_dict[mod_cat]
-                for (model, enabled) in cat_dic:
+                for model, enabled in cat_dic:
                     if enabled:
-                        m_list.append(self.model_dict[model])
+                        m_list.append(self.model_dictionary[model])
         except Exception:
             msg = traceback.format_exc()
@@ -1906 +1946 @@
                     wx.PostEvent(self.parent, StatusEvent(status=msg))
                     return
-            except:
+            except Exception:
                 tcrtl.SetBackgroundColour("pink")
                 msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
@@ -1963 +2003 @@
                     wx.PostEvent(self._manager.parent, StatusEvent(status=msg))
                     return
-            except:
+            except Exception:
                 tcrtl.SetBackgroundColour("pink")
                 msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1]
@@ -2063 +2103 @@
 
         if struct_factor is not None:
-            from sasmodels.sasview_model import MultiplicationModel
             self.model = MultiplicationModel(form_factor(self.multi_factor),
                                              struct_factor())
@@ -2141 +2180 @@
             # q value from qx and qy
             radius = np.sqrt(data.qx_data * data.qx_data +
-                                data.qy_data * data.qy_data)
+                             data.qy_data * data.qy_data)
             # get unmasked index
             index_data = (float(self.qmin.GetValue()) <= radius) & \
@@ -2370 +2409 @@
         put gaussian dispersity into current model
         """
-        if len(self.param_toFit) > 0:
+        if self.param_toFit:
             for item in self.fittable_param:
                 if item in self.param_toFit:
@@ -2385 +2424 @@
         self.weights = {}
 
-        # from sas.models.dispersion_models import GaussianDispersion
-        from sasmodels.weights import GaussianDispersion
-        if len(self.disp_cb_dict) == 0:
-            self.save_current_state()
+        if not self.disp_cb_dict:
             self.sizer4_4.Clear(True)
-            self.Layout()
-            return
-        if (len(self.disp_cb_dict) > 0):
+        else:
             for p in self.disp_cb_dict:
                 # The parameter was un-selected.
@@ -2465 +2499 @@
                 self._disp_obj_dict[name1] = disp_model
                 self.model.set_dispersion(param_name, disp_model)
-                self.state._disp_obj_dict[name1] = disp_model.type
+                self.state.disp_obj_dict[name1] = disp_model.type
 
                 value1 = str(format_number(self.model.getParam(name1), True))
@@ -2580 +2614 @@
         self._disp_obj_dict[name] = disp
         self.model.set_dispersion(name.split('.')[0], disp)
-        self.state._disp_obj_dict[name] = disp.type
+        self.state.disp_obj_dict[name] = disp.type
         self.values[name] = values
         self.weights[name] = weights
@@ -2938 +2972 @@
             # go through the parameters
             strings = self._get_copy_helper(self.parameters,
-                                           self.orientation_params)
+                                            self.orientation_params)
             content += strings
 
             # go through the fittables
             strings = self._get_copy_helper(self.fittable_param,
-                                           self.orientation_params_disp)
+                                            self.orientation_params_disp)
             content += strings
 
             # go through the fixed params
             strings = self._get_copy_helper(self.fixed_param,
-                                           self.orientation_params_disp)
+                                            self.orientation_params_disp)
             content += strings
 
             # go through the str params
             strings = self._get_copy_helper(self.str_parameters,
-                                           self.orientation_params)
+                                            self.orientation_params)
             content += strings
             return content
@@ -2966 +3000 @@
         the names of parameters that have been fitted
 
-        :returns: all_params - A list of all parameters, in the format of 
+        :returns: all_params - A list of all parameters, in the format of
         self.parameters
         :returns: fitted_par_names - A list of the names of parameters that have
@@ -3043 +3077 @@
                 # Only print errors for fitted parameters
                 content += param[4].GetValue()
-                content += tab 
+                content += tab
 
         return content
@@ -3063 +3097 @@
             # Do nothing if self.parameters doesn't exist
             return False
-        
-        content = '\\begin{table}'
-        content += '\\begin{tabular}[h]'
+
+        content = r'\begin{table}'
+        content += r'\begin{tabular}[h]'
 
         crlf = chr(13) + chr(10)
@@ -3075 +3109 @@
         for param in all_params:
             content += 'l|l|'
-        content += '}\hline'
+        content += r'}\hline'
         content += crlf
 
@@ -3081 +3115 @@
         for index, param in enumerate(all_params):
             name = param[1] # Parameter name
-            content += name.replace('_', '\_')  # Escape underscores
+            content += name.replace('_', r'\_')  # Escape underscores
             if name in fitted_param_names:
                 # Only print errors for fitted parameters
                 content += ' & '
-                content += name.replace('_', '\_') + "\_err"
+                content += name.replace('_', r'\_') + r"\_err"
             if index < len(all_params) - 1:
                 content += ' & '
 
-        content += '\\\\ \\hline'
+        content += r'\\ \hline'
         content += crlf
 
@@ -3108 +3142 @@
             if index < len(all_params) - 1:
                 content += ' & '
-        
-        content += '\\\\ \\hline'
+
+        content += r'\\ \hline'
         content += crlf
-        content += '\\end{tabular}'
-        content += '\\end{table}'
+        content += r'\end{tabular}'
+        content += r'\end{table}'
 
         return content
@@ -3369 +3403 @@
                                 if name.endswith('.npts'):
                                     pd = int(pd)
-                            except:
+                            except Exception:
                                 # continue
                                 if not pd and pd != '':
@@ -3455 +3489 @@
                 self._disp_obj_dict[name] = disp_model
                 self.model.set_dispersion(param_name, disp_model)
-                self.state._disp_obj_dict[name] = disp_model.type
+                self.state.disp_obj_dict[name] = disp_model.type
                 # TODO: It's not an array, why update values and weights?
                 self.model._persistency_dict[param_name] = \
@@ -3555 +3589 @@
         self.model_box.Clear()
 
-        if category == 'Plugin Models':
+        if category == CUSTOM_MODEL:
             for model in self.model_list_box[category]:
                 str_m = str(model).split(".")[0]
@@ -3561 +3595 @@
 
         else:
-            for (model, enabled) in sorted(self.master_category_dict[category],
-                                           key=lambda name: name[0]):
-                if(enabled):
+            for model, enabled in sorted(self.master_category_dict[category],
+                                         key=lambda name: name[0]):
+                if enabled:
                     self.model_box.Append(model)
 
@@ -3804 +3838 @@
         self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus)
         self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus
-        if kill_focus_callback is None else kill_focus_callback)
+                  if kill_focus_callback is None else kill_focus_callback)
         self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter
-        if text_enter_callback is None else text_enter_callback)
+                  if text_enter_callback is None else text_enter_callback)
         if not ON_MAC:
             self.Bind(wx.EVT_LEFT_UP, self._highlight_text
-            if mouse_up_callback is None else mouse_up_callback)
+                      if mouse_up_callback is None else mouse_up_callback)
 
     def _on_set_focus(self, event):

src/sas/sasgui/perspectives/fitting/batchfitpage.py

@@ -5 +5 @@
 import wx.lib.newevent
 import math
+
+from sas.sascalc.fit.qsmearing import smear_selection
+
 from sas.sasgui.guiframe.events import StatusEvent
 from sas.sasgui.guiframe.events import NewPlotEvent
+from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent
+from sas.sasgui.perspectives.fitting.fitpage import FitPage
+from sas.sasgui.perspectives.fitting.fitpage import check_data_validity
 
 (Chi2UpdateEvent, EVT_CHI2_UPDATE) = wx.lib.newevent.NewEvent()
@@ -13 +19 @@
 SMEAR_SIZE_L = 0.00
 SMEAR_SIZE_H = 0.00
-
-from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent
-from sas.sascalc.data_util.qsmearing import smear_selection
-from sas.sasgui.perspectives.fitting.fitpage import FitPage
-from sas.sasgui.perspectives.fitting.fitpage import check_data_validity
 
 class BatchFitPage(FitPage):
@@ -76 +77 @@
 #         """
 #         is_2Ddata = False
-#         
+#
 #         # Check if data is 2D
 #         if self.data.__class__.__name__ ==  "Data2D" or \
 #                         self.enable2D:
 #             is_2Ddata = True
-#             
-#         title = "Fitting"     
+#
+#         title = "Fitting"
 #         self._get_smear_info()
-#         
+#
 #         #Sizers
 #         box_description_range = wx.StaticBox(self, wx.ID_ANY, str(title))
-#         boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)      
+#         boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)
 #         self.sizer_set_smearer = wx.BoxSizer(wx.VERTICAL)
 #         #sizer_smearer = wx.BoxSizer(wx.HORIZONTAL)
@@ -93 +94 @@
 #         self.sizer_set_masking = wx.BoxSizer(wx.HORIZONTAL)
 #         sizer_chi2 = wx.BoxSizer(wx.VERTICAL)
-# 
+#
 #         sizer_fit = wx.GridSizer(2, 4, 2, 6)
 #         #Fit button
@@ -100 +101 @@
 #         self.btFit.Bind(wx.EVT_BUTTON, self._onFit, id= self.btFit.GetId())
 #         self.btFit.SetToolTipString("Start fitting.")
-# 
+#
 #         # Update and Draw button
 #         self.draw_button = wx.Button(self, self._ids.next(), 'Compute', size=(88, 24))
 #         self.draw_button.Bind(wx.EVT_BUTTON, \
 #                               self._onDraw,id=self.draw_button.GetId())
-#         self.draw_button.SetToolTipString("Compute and Draw.")  
+#         self.draw_button.SetToolTipString("Compute and Draw.")
 #         sizer_fit.Add(self.draw_button, 0, 0)
-#         sizer_fit.Add(self.btFit, 0, 0) 
+#         sizer_fit.Add(self.btFit, 0, 0)
 #         sizer_chi2.Add((-1, 5))
 #         # get smear_selection
@@ -114 +115 @@
 #          #2D data? default
 #         is_2Ddata = False
-#         
+#
 #         #check if it is 2D data
 #         if self.data.__class__.__name__ ==  "Data2D" or \
 #                         self.enable2D:
 #             is_2Ddata = True
-#             
+#
 #         self.sizer5.Clear(True)
-#      
+#
 #         self.qmin  = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
-#                                           style=wx.TE_PROCESS_ENTER, 
+#                                           style=wx.TE_PROCESS_ENTER,
 #                                     text_enter_callback = self._onQrangeEnter)
 #         self.qmin.SetValue(str(self.qmin_x))
 #         self.qmin.SetToolTipString("Minimun value of Q in linear scale.")
-#      
+#
 #         self.qmax  = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20),
-#                                           style=wx.TE_PROCESS_ENTER, 
+#                                           style=wx.TE_PROCESS_ENTER,
 #                                         text_enter_callback=self._onQrangeEnter)
 #         self.qmax.SetValue(str(self.qmax_x))
 #         self.qmax.SetToolTipString("Maximum value of Q in linear scale.")
-#         
+#
 #         id = self._ids.next()
 #         self.reset_qrange =wx.Button(self, id, 'Reset', size=(77, 20))
-#       
+#
 #         self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked, id=id)
 #         self.reset_qrange.SetToolTipString(\
 #                                     "Reset Q range to the default values")
-#      
+#
 #         sizer_horizontal = wx.BoxSizer(wx.HORIZONTAL)
 #         sizer = wx.GridSizer(2, 4, 2, 6)
-# 
+#
 #         self.btEditMask = wx.Button(self, self._ids.next(),'Editor', size=(88, 23))
-#         self.btEditMask.Bind(wx.EVT_BUTTON, 
+#         self.btEditMask.Bind(wx.EVT_BUTTON,
 #                              self._onMask,id=self.btEditMask.GetId())
 #         self.btEditMask.SetToolTipString("Edit Mask.")
 #         self.EditMask_title = wx.StaticText(self, wx.ID_ANY, ' Masking(2D)')
-# 
+#
 #         sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Q range'))
 #         sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Min[1/A]'))
 #         sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Max[1/A]'))
 #         sizer.Add(self.EditMask_title)
-#  
-#         sizer.Add(self.reset_qrange)   
+#
+#         sizer.Add(self.reset_qrange)
 #         sizer.Add(self.qmin)
 #         sizer.Add(self.qmax)
-# 
+#
 #         sizer.Add(self.btEditMask)
-#         boxsizer_range.Add(sizer_chi2) 
+#         boxsizer_range.Add(sizer_chi2)
 #         boxsizer_range.Add((10, 10))
 #         boxsizer_range.Add(sizer)
-#         
+#
 #         boxsizer_range.Add((10, 15))
 #         boxsizer_range.Add(sizer_fit)
 #         if is_2Ddata:
-#             self.btEditMask.Enable()  
-#             self.EditMask_title.Enable() 
+#             self.btEditMask.Enable()
+#             self.EditMask_title.Enable()
 #         else:
-#             self.btEditMask.Disable()  
+#             self.btEditMask.Disable()
 #             self.EditMask_title.Disable()
-# 
+#
 #         ## save state
 #         #self.save_current_state()
-# 
+#
 #         self.sizer5.Add(boxsizer_range, 0, wx.EXPAND | wx.ALL, 10)
 #         self.sizer5.Layout()
-#        
-#     def _on_select_model(self, event=None): 
+#
+#     def _on_select_model(self, event=None):
 #         """
 #         call back for model selection
-#         """  
-#         
-#         self.Show(False)    
-#         self._on_select_model_helper() 
-#         self.set_model_param_sizer(self.model)                   
+#         """
+#
+#         self.Show(False)
+#         self._on_select_model_helper()
+#         self.set_model_param_sizer(self.model)
 #         if self.model is None:
 #             self._set_bookmark_flag(False)
@@ -199 +200 @@
 #         self.state.structurecombobox = self.structurebox.GetCurrentSelection()
 #         self.state.formfactorcombobox = self.formfactorbox.GetCurrentSelection()
-#       
+#
 #         if self.model is not None:
 #             self._set_copy_flag(True)
@@ -206 +207 @@
 #                 self._set_bookmark_flag(False)
 #                 self._keep.Enable(False)
-#                 
+#
 #             temp_smear = None
 #             ## event to post model to fit to fitting plugins
 #             (ModelEventbox, _) = wx.lib.newevent.NewEvent()
-#          
-#             ## set smearing value whether or not 
+#
+#             ## set smearing value whether or not
 #             #    the data contain the smearing info
-#             evt = ModelEventbox(model=self.model, 
-#                                         smearer=temp_smear, 
+#             evt = ModelEventbox(model=self.model,
+#                                         smearer=temp_smear,
 #                                         qmin=float(self.qmin_x),
 #                                         uid=self.uid,
-#                                      qmax=float(self.qmax_x)) 
-#    
+#                                      qmax=float(self.qmax_x))
+#
 #             self._manager._on_model_panel(evt=evt)
 #             self.mbox_description.SetLabel("Model [%s]" % str(self.model.name))
 #             self.state.model = self.model.clone()
 #             self.state.model.name = self.model.name
-# 
-#             
+#
+#
 #         if event is not None:
 #             ## post state to fit panel
 #             new_event = PageInfoEvent(page = self)
-#             wx.PostEvent(self.parent, new_event) 
+#             wx.PostEvent(self.parent, new_event)
 #             #update list of plugins if new plugin is available
 #             if self.plugin_rbutton.GetValue():
@@ -243 +244 @@
 #             self._draw_model()
 #         self.SetupScrolling()
-#         self.Show(True)   
-#         
+#         self.Show(True)
+#
 #     def _update_paramv_on_fit(self):
 #         """
@@ -253 +254 @@
 #         self.fitrange = True
 #         is_modified = False
-# 
+#
 #         if self.model is not None:
 #             ##Check the values
@@ -259 +260 @@
 #             self._check_value_enter( self.fixed_param)
 #             self._check_value_enter( self.parameters)
-# 
-#             # If qmin and qmax have been modified, update qmin and qmax and 
+#
+#             # If qmin and qmax have been modified, update qmin and qmax and
 #              # Here we should check whether the boundaries have been modified.
-#             # If qmin and qmax have been modified, update qmin and qmax and 
+#             # If qmin and qmax have been modified, update qmin and qmax and
 #             # set the is_modified flag to True
 #             self.fitrange = self._validate_qrange(self.qmin, self.qmax)
@@ -273 +274 @@
 #                     self.qmax_x = tempmax
 #                 if tempmax == tempmin:
-#                     flag = False    
+#                     flag = False
 #                 #temp_smearer = None
 #                 if self._is_2D():
-#                     # only 2D case set mask  
+#                     # only 2D case set mask
 #                     flag = self._validate_Npts()
 #                     if not flag:
 #                         return flag
 #             else: flag = False
-#         else: 
+#         else:
 #             flag = False
-# 
-#         #For invalid q range, disable the mask editor and fit button, vs.    
+#
+#         #For invalid q range, disable the mask editor and fit button, vs.
 #         if not self.fitrange:
 #             #self.btFit.Disable()
@@ -293 +294 @@
 #             if self._is_2D() and  self.data is not None:
 #                 self.btEditMask.Enable(True)
-# 
+#
 #         if not flag:
 #             msg = "Cannot Plot or Fit :Must select a "
 #             msg += " model or Fitting range is not valid!!!  "
 #             wx.PostEvent(self.parent.parent, StatusEvent(status=msg))
-#         
+#
 #         self.save_current_state()
-#    
-#         return flag  
+#
+#         return flag
 #     def save_current_state(self):
 #         """
 #         Currently no save option implemented for batch page
 #         """
-#         pass 
+#         pass
 #     def save_current_state_fit(self):
 #         """
@@ -314 +315 @@
 #     def set_data(self, data):
 #         """
-#         reset the current data 
+#         reset the current data
 #         """
 #         #id = None
@@ -340 +341 @@
 #             self._set_save_flag(False)
 #             self._set_preview_flag(True)
-#   
+#
 #             self.formfactorbox.Enable()
 #             self.structurebox.Enable()
@@ -346 +347 @@
 #             #set maximum range for x in linear scale
 #             if not hasattr(self.data,"data"): #Display only for 1D data fit
-#                 # Minimum value of data   
+#                 # Minimum value of data
 #                 data_min = min(self.data.x)
-#                 # Maximum value of data  
+#                 # Maximum value of data
 #                 data_max = max(self.data.x)
-#                 self.btEditMask.Disable()  
+#                 self.btEditMask.Disable()
 #                 self.EditMask_title.Disable()
 #             else:
-#                 
-#                 ## Minimum value of data 
+#
+#                 ## Minimum value of data
 #                 data_min = 0
-#                 x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax)) 
+#                 x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))
 #                 y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax))
-#                 ## Maximum value of data  
+#                 ## Maximum value of data
 #                 data_max = math.sqrt(x*x + y*y)
-#                 self.btEditMask.Enable()  
-#                 self.EditMask_title.Enable() 
-# 
+#                 self.btEditMask.Enable()
+#                 self.EditMask_title.Enable()
+#
 #         self.dataSource.SetValue(data_name)
 #         self.qmin_x = data_min
@@ -375 +376 @@
 #         self.state.qmin = self.qmin_x
 #         self.state.qmax = self.qmax_x
-#         
+#
 #         #update model plot with new data information
 #         if flag:
@@ -385 +386 @@
 #                 self.enable2D = False
 #                 self.model_view.SetLabel("1D Mode")
-#                 
+#
 #             self.model_view.Disable()
-#             
-#             wx.PostEvent(self._manager.parent, 
+#
+#             wx.PostEvent(self._manager.parent,
 #                              NewPlotEvent(group_id=group_id,
 #                                                action="delete"))
 #             #plot the current selected data
-#             wx.PostEvent(self._manager.parent, NewPlotEvent(plot=self.data, 
+#             wx.PostEvent(self._manager.parent, NewPlotEvent(plot=self.data,
 #                                                     title=str(self.data.title)))
 #             self._manager.store_data(uid=self.uid, data=data,

src/sas/sasgui/perspectives/fitting/fit_thread.py

@@ -29 +29 @@
                  worktime=0.03,
                  reset_flag=False):
-        CalcThread.__init__(self,
-                 completefn,
-                 updatefn,
-                 yieldtime,
-                 worktime)
+        CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime)
         self.handler = handler
         self.fitter = fn
@@ -93 +89 @@
             # Real code should not print, but this is an example...
             #print "keyboard exception"
-            #Stop on exception during fitting. Todo: need to put 
+            #Stop on exception during fitting. Todo: need to put
             #some mssg and reset progress bar.
 
@@ -100 +96 @@
             if self.handler is not None:
                 self.handler.stop(msg=msg)
-        except:
+        except:  # catch-all: show every exception which stops the thread
             import traceback
             if self.handler is not None:

src/sas/sasgui/perspectives/fitting/fitpanel.py

@@ -9 +9 @@
 from wx.aui import AuiNotebook as nb
 
+from sas.sascalc.fit.models import ModelManager
+
 from sas.sasgui.guiframe.panel_base import PanelBase
 from sas.sasgui.guiframe.events import PanelOnFocusEvent, StatusEvent
 from sas.sasgui.guiframe.dataFitting import check_data_validity
-from sas.sasgui.perspectives.fitting.simfitpage import SimultaneousFitPage
-
-import basepage
-import models
+
+
+from . import basepage
+from .fitpage import FitPage
+from .simfitpage import SimultaneousFitPage
+from .batchfitpage import BatchFitPage
+from .fitting_widgets import BatchDataDialog
+
 _BOX_WIDTH = 80
 
@@ -46 +52 @@
         self.event_owner = None
         # dictionary of miodel {model class name, model class}
-        self.menu_mng = models.ModelManager()
+        self.menu_mng = ModelManager()
         self.model_list_box = self.menu_mng.get_model_list()
         # pageClosedEvent = nb.EVT_FLATNOTEBOOK_PAGE_CLOSING
@@ -114 +120 @@
         """
         temp = self.menu_mng.update()
-        if len(temp):
+        if temp:
             self.model_list_box = temp
         return temp
@@ -121 +127 @@
         """
         """
-        temp = self.menu_mng.plugins_reset()
-        if len(temp):
-            self.model_list_box = temp
-        return temp
+        self.model_list_box = self.menu_mng.plugins_reset()
+        return self.model_list_box
 
     def get_page_by_id(self, uid):
@@ -298 +302 @@
         self.model_list_box = dict
 
-    def set_model_dict(self, m_dict):
+    def set_model_dictionary(self, model_dictionary):
         """
         copy a dictionary of model name -> model object
 
-        :param m_dict: dictionary linking model name -> model object
+        :param model_dictionary: dictionary linking model name -> model object
         """
 
@@ -316 +320 @@
         Add the simultaneous fit page
         """
-        from simfitpage import SimultaneousFitPage
         page_finder = self._manager.get_page_finder()
         if caption == "Const & Simul Fit":
@@ -344 +347 @@
         """
         if self.batch_on:
-            from batchfitpage import BatchFitPage
             panel = BatchFitPage(parent=self)
             self.batch_page_index += 1
@@ -351 +353 @@
         else:
             # Increment index of fit page
-            from fitpage import FitPage
             panel = FitPage(parent=self)
             self.fit_page_index += 1
@@ -359 +360 @@
         panel._set_save_flag(not panel.batch_on)
         panel.set_model_dictionary(self.model_dictionary)
-        panel.populate_box(model_dict=self.model_list_box)
+        panel.populate_box(model_list_box=self.model_list_box)
         panel.formfactor_combo_init()
         panel.set_manager(self._manager)
@@ -445 +446 @@
         if data_1d_list and data_2d_list:
             # need to warning the user that this batch is a special case
-            from sas.sasgui.perspectives.fitting.fitting_widgets import \
-                BatchDataDialog
             dlg = BatchDataDialog(self)
             if dlg.ShowModal() == wx.ID_OK:

src/sas/sasgui/perspectives/fitting/fitproblem.py

@@ -14 +14 @@
 ################################################################################
 import copy
-from sas.sascalc.data_util.qsmearing import smear_selection
-
-class FitProblemComponent(object):
+
+from sas.sascalc.fit.qsmearing import smear_selection
+
+class FitProblem(object):
     """
-    Inferface containing information to store data, model, range of data, etc...
-    and retreive this information. This is an inferface
-    for a fitProblem i.e relationship between data and model.
+    Define the relationship between data and model, including range, weights,
+    etc.
     """
+    def __init__(self):
+        """
+        contains information about data and model to fit
+        """
+        ## data used for fitting
+        self.fit_data = None
+        self.theory_data = None
+        self.residuals = None
+        # original data: should not be modified
+        self.original_data = None
+        ## the current model
+        self.model = None
+        ## if 1 this fit problem will be selected to fit , if 0
+        ## it will not be selected for fit
+        self.schedule = 0
+        ##list containing parameter name and value
+        self.list_param = []
+        self.list_param2fit = []
+        ## smear object to smear or not data1D
+        self.smearer_computed = False
+        self.smearer_enable = False
+        self.smearer_computer_value = None
+        ## fitting range
+        self.qmin = None
+        self.qmax = None
+        # fit weight
+        self.weight = None
+        self.result = None
+        self.fit_tab_caption = None
+        self.name_per_page = None
+
     def enable_smearing(self, flag=False):
         """
@@ -27 +58 @@
             flag is 0 ingore smear value.
         """
+        self.smearer_enable = flag
+
+    def set_smearer(self, smearer):
+        """
+        save reference of  smear object on fitdata
+
+        :param smear: smear object from DataLoader
+
+        """
+        self.smearer_computer_value = smearer
 
     def get_smearer(self):
@@ -32 +73 @@
         return smear object
         """
+        if not self.smearer_enable:
+            return None
+        if not self.smearer_computed:
+            #smeari_selection should be call only once per fitproblem
+            self.smearer_computer_value = smear_selection(self.fit_data,
+                                                          self.model)
+            self.smearer_computed = True
+        return self.smearer_computer_value
+
     def save_model_name(self, name):
         """
         """
+        self.name_per_page = name
 
     def get_name(self):
         """
         """
+        return self.name_per_page
 
     def set_model(self, model):
@@ -46 +98 @@
         :param name: name created for model
         """
+        self.model = model
+        self.smearer_computer_value = smear_selection(self.fit_data,
+                                                      self.model)
+        self.smearer_computed = True
 
     def get_model(self):
@@ -51 +107 @@
         :return: saved model
         """
+        return self.model
 
     def set_residuals(self, residuals):
@@ -57 +114 @@
         :param data: data selected
         """
+        self.residuals = residuals
 
     def get_residuals(self):
@@ -62 +120 @@
         :return: residuals
         """
+        return self.residuals
 
     def set_theory_data(self, data):
         """
         save a copy of the data select to fit
+
         :param data: data selected
-        """
+
+        """
+        self.theory_data = copy.deepcopy(data)
 
     def get_theory_data(self):
         """
-        :return: list of data dList
-        """
+        :return: theory generated with the current model and data of this class
+        """
+        return self.theory_data
 
     def set_fit_data(self, data):
         """
-        Store of list of data and create  by create new fitproblem of each data
-        id, if there was existing information about model, this information
-        get copy to the new fitproblem
+        Store data associated with this class
         :param data: list of data selected
         """
+        self.original_data = None
+        self.fit_data = None
+        # original data: should not be modified
+        self.original_data = data
+        # fit data: used for fit and can be modified for convenience
+        self.fit_data = copy.deepcopy(data)
+        self.smearer_computer_value = smear_selection(self.fit_data, self.model)
+        self.smearer_computed = True
+        self.result = None
 
     def get_fit_data(self):
         """
-        """
+        :return: data associate with this class
+        """
+        return self.fit_data
+
+    def get_origin_data(self):
+        """
+        """
+        return self.original_data
+
+    def set_weight(self, is2d, flag=None):
+        """
+        Received flag and compute error on data.
+        :param flag: flag to transform error of data.
+        :param is2d: flag to distinguish 1D to 2D Data
+        """
+        from sas.sasgui.perspectives.fitting.utils import get_weight
+        # send original data for weighting
+        self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag)
+        if is2d:
+            self.fit_data.err_data = self.weight
+        else:
+            self.fit_data.dy = self.weight
+
+    def get_weight(self):
+        """
+        returns weight array
+        """
+        return self.weight
+
+    def set_param2fit(self, list):
+        """
+        Store param names to fit (checked)
+        :param list: list of the param names
+        """
+        self.list_param2fit = list
+
+    def get_param2fit(self):
+        """
+        return the list param names to fit
+        """
+        return self.list_param2fit
 
     def set_model_param(self, name, value=None):
@@ -92 +202 @@
         :param value: value of that parameter
         """
-
-    def set_param2fit(self, list):
-        """
-        Store param names to fit (checked)
-        :param list: list of the param names
-        """
-
-    def get_param2fit(self):
-        """
-        return the list param names to fit
-        """
+        self.list_param.append([name, value])
 
     def get_model_param(self):
@@ -108 +208 @@
         return list of couple of parameter name and value
         """
+        return self.list_param
 
     def schedule_tofit(self, schedule=0):
@@ -113 +214 @@
         set schedule to true to decide if this fit  must be performed
         """
+        self.schedule = schedule
 
     def get_scheduled(self):
@@ -118 +220 @@
         return true or false if a problem as being schedule for fitting
         """
+        return self.schedule
 
     def set_range(self, qmin=None, qmax=None):
         """
         set fitting range
-        """
+        :param qmin: minimum value to consider for the fit range
+        :param qmax: maximum value to consider for the fit range
+        """
+        self.qmin = qmin
+        self.qmax = qmax
 
     def get_range(self):
         """
         :return: fitting range
-        """
-
-    def set_weight(self, flag=None):
-        """
-        set fitting range
-        """
-
-    def get_weight(self):
-        """
-        get fitting weight
-        """
+
+        """
+        return self.qmin, self.qmax
 
     def clear_model_param(self):
@@ -143 +242 @@
         clear constraint info
         """
+        self.list_param = []
 
     def set_fit_tab_caption(self, caption):
         """
-        store the caption of the page associated with object
-        """
+        """
+        self.fit_tab_caption = str(caption)
 
     def get_fit_tab_caption(self):
         """
-        Return the caption of the page associated with object
-        """
+        """
+        return self.fit_tab_caption
 
     def set_graph_id(self, id):
@@ -158 +258 @@
         Set graph id (from data_group_id at the time the graph produced)
         """
+        self.graph_id = id
 
     def get_graph_id(self):
@@ -163 +264 @@
         Get graph_id
         """
+        return self.graph_id
 
     def set_result(self, result):
         """
         """
+        self.result = result
 
     def get_result(self):
@@ -172 +275 @@
         get result
         """
-
-
-class FitProblemDictionary(FitProblemComponent, dict):
+        return self.result
+
+
+class FitProblemDictionary(dict):
     """
     This module implements a dictionary of fitproblem objects
     """
     def __init__(self):
-        FitProblemComponent.__init__(self)
         dict.__init__(self)
         ## the current model
@@ -206 +309 @@
         self._smear_on = flag
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.enable_smearing(flag)
-        else:
-            if fid in self.iterkeys():
-                self[fid].enable_smearing(flag)
+        elif fid in self:
+            self[fid].enable_smearing(flag)
 
     def set_smearer(self, smearer, fid=None):
@@ -218 +320 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_smearer(smearer)
-        else:
-            if fid in self.iterkeys():
-                self[fid].set_smearer(smearer)
+        elif fid in self:
+            self[fid].set_smearer(smearer)
 
     def get_smearer(self, fid=None):
@@ -228 +329 @@
         return smear object
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_smearer()
 
@@ -235 +336 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.save_model_name(name)
-        else:
-            if fid in self.iterkeys():
-                self[fid].save_model_name(name)
+        elif fid in self:
+            self[fid].save_model_name(name)
 
     def get_name(self, fid=None):
@@ -246 +346 @@
         result = []
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 result.append(value.get_name())
-        else:
-            if fid in self.iterkeys():
-                result.append(self[fid].get_name())
+        elif fid in self:
+            result.append(self[fid].get_name())
         return result
 
@@ -261 +360 @@
         self.model = model
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_model(self.model)
-        else:
-            if fid in self.iterkeys():
-                self[fid].set_model(self.model)
+        elif fid in self:
+            self[fid].set_model(self.model)
 
     def get_model(self, fid):
@@ -271 +369 @@
         :return: saved model
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_model()
 
@@ -291 +389 @@
         :param data: data selected
         """
-        if fid in self.iterkeys():
+        if fid in self:
             self[fid].set_residuals(residuals)
 
@@ -298 +396 @@
         :return: residuals
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_residuals()
 
@@ -306 +404 @@
         :param data: data selected
         """
-        if fid in self.iterkeys():
+        if fid in self:
             self[fid].set_theory_data(data)
 
@@ -313 +411 @@
         :return: list of data dList
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_theory_data()
 
@@ -322 +420 @@
         :note: only data changes in the fit problem
         """
-        if data.id not in self.iterkeys():
+        if data.id not in self:
             self[data.id] = FitProblem()
         self[data.id].set_fit_data(data)
@@ -336 +434 @@
             data = []
         for d in data:
-            if (d is not None):
-                if (d.id not in self.iterkeys()):
+            if d is not None:
+                if d.id not in self:
                     self[d.id] = FitProblem()
                 self[d.id].set_fit_data(d)
@@ -348 +446 @@
         :param fid: key representing a fitproblem, usually extract from data id
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_fit_data()
 
@@ -358 +456 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_model_param(name, value)
-        else:
-            if fid in self.iterkeys():
-                self[fid].set_model_param(name, value)
+        elif fid in self:
+            self[fid].set_model_param(name, value)
 
     def get_model_param(self, fid):
@@ -368 +465 @@
         return list of couple of parameter name and value
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_model_param()
 
@@ -389 +486 @@
         """
         self.scheduled = schedule
-        for value in self.itervalues():
+        for value in self.values():
             value.schedule_tofit(schedule)
 
@@ -405 +502 @@
         self.qmax = qmax
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_range(self.qmin, self.qmax)
-        else:
-            if fid in self.iterkeys():
-                self[fid].value.set_range(self.qmin, self.qmax)
+        elif fid in self:
+            self[fid].value.set_range(self.qmin, self.qmax)
 
     def get_range(self, fid):
@@ -415 +511 @@
         :return: fitting range
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_range()
 
@@ -423 +519 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.set_weight(flag=flag, is2d=is2d)
-        else:
-            if fid in self.iterkeys():
-                self[fid].set_weight(flag=flag, is2d=is2d)
+        elif fid in self:
+            self[fid].set_weight(flag=flag, is2d=is2d)
 
     def get_weight(self, fid=None):
@@ -433 +528 @@
         return fit weight
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_weight()
 
@@ -441 +536 @@
         """
         if fid is None:
-            for value in self.itervalues():
+            for value in self.values():
                 value.clear_model_param()
-        else:
-            if fid in self.iterkeys():
-                self[fid].clear_model_param()
+        elif fid in self:
+            self[fid].clear_model_param()
 
     def get_fit_problem(self):
@@ -451 +545 @@
         return fitproblem contained in this dictionary
         """
-        return self.itervalues()
+        return self.values()
 
     def set_result(self, result, fid):
         """
         """
-        if fid in self.iterkeys():
+        if fid in self:
             self[fid].set_result(result)
 
@@ -470 +564 @@
         get result
         """
-        if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_result()
 
@@ -490 +584 @@
         """
         return self.graph_id
-
-
-class FitProblem(FitProblemComponent):
-    """
-    FitProblem class allows to link a model with the new name created in _on_model,
-    a name theory created with that model  and the data fitted with the model.
-    FitProblem is mostly used  as value of the dictionary by fitting module.
-    """
-    def __init__(self):
-        FitProblemComponent.__init__(self)
-        """
-        contains information about data and model to fit
-        """
-        ## data used for fitting
-        self.fit_data = None
-        self.theory_data = None
-        self.residuals = None
-        # original data: should not be modified
-        self.original_data = None
-        ## the current model
-        self.model = None
-        ## if 1 this fit problem will be selected to fit , if 0
-        ## it will not be selected for fit
-        self.schedule = 0
-        ##list containing parameter name and value
-        self.list_param = []
-        ## smear object to smear or not data1D
-        self.smearer_computed = False
-        self.smearer_enable = False
-        self.smearer_computer_value = None
-        ## fitting range
-        self.qmin = None
-        self.qmax = None
-        # fit weight
-        self.weight = None
-        self.result = None
-
-    def enable_smearing(self, flag=False):
-        """
-        :param flag: bool.When flag is 1 get the computer smear value. When
-            flag is 0 ingore smear value.
-        """
-        self.smearer_enable = flag
-
-    def set_smearer(self, smearer):
-        """
-        save reference of  smear object on fitdata
-
-        :param smear: smear object from DataLoader
-
-        """
-        self.smearer_computer_value = smearer
-
-    def get_smearer(self):
-        """
-        return smear object
-        """
-        if not self.smearer_enable:
-            return None
-        if not self.smearer_computed:
-            #smeari_selection should be call only once per fitproblem
-            self.smearer_computer_value = smear_selection(self.fit_data,
-                                                           self.model)
-            self.smearer_computed = True
-        return self.smearer_computer_value
-
-    def save_model_name(self, name):
-        """
-        """
-        self.name_per_page = name
-
-    def get_name(self):
-        """
-        """
-        return self.name_per_page
-
-    def set_model(self, model):
-        """
-        associates each model with its new created name
-        :param model: model selected
-        :param name: name created for model
-        """
-        self.model = model
-        self.smearer_computer_value = smear_selection(self.fit_data,
-                                                           self.model)
-        self.smearer_computed = True
-
-    def get_model(self):
-        """
-        :return: saved model
-        """
-        return self.model
-
-    def set_residuals(self, residuals):
-        """
-        save a copy of residual
-        :param data: data selected
-        """
-        self.residuals = residuals
-
-    def get_residuals(self):
-        """
-        :return: residuals
-        """
-        return self.residuals
-
-    def set_theory_data(self, data):
-        """
-        save a copy of the data select to fit
-
-        :param data: data selected
-
-        """
-        self.theory_data = copy.deepcopy(data)
-
-    def get_theory_data(self):
-        """
-        :return: theory generated with the current model and data of this class
-        """
-        return self.theory_data
-
-    def set_fit_data(self, data):
-        """
-        Store data associated with this class
-        :param data: list of data selected
-        """
-        self.original_data = None
-        self.fit_data = None
-        # original data: should not be modified
-        self.original_data = data
-        # fit data: used for fit and can be modified for convenience
-        self.fit_data = copy.deepcopy(data)
-        self.smearer_computer_value = smear_selection(self.fit_data,
-                                                           self.model)
-        self.smearer_computed = True
-        self.result = None
-
-    def get_fit_data(self):
-        """
-        :return: data associate with this class
-        """
-        return self.fit_data
-
-    def get_origin_data(self):
-        """
-        """
-        return self.original_data
-
-    def set_weight(self, is2d, flag=None):
-        """
-        Received flag and compute error on data.
-        :param flag: flag to transform error of data.
-        :param is2d: flag to distinguish 1D to 2D Data
-        """
-        from sas.sasgui.perspectives.fitting.utils import get_weight
-        # send original data for weighting
-        self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag)
-        if is2d:
-            self.fit_data.err_data = self.weight
-        else:
-            self.fit_data.dy = self.weight
-
-    def get_weight(self):
-        """
-        returns weight array
-        """
-        return self.weight
-
-    def set_param2fit(self, list):
-        """
-        Store param names to fit (checked)
-        :param list: list of the param names
-        """
-        self.list_param2fit = list
-
-    def get_param2fit(self):
-        """
-        return the list param names to fit
-        """
-        return self.list_param2fit
-
-    def set_model_param(self, name, value=None):
-        """
-        Store the name and value of a parameter of this fitproblem's model
-        :param name: name of the given parameter
-        :param value: value of that parameter
-        """
-        self.list_param.append([name, value])
-
-    def get_model_param(self):
-        """
-        return list of couple of parameter name and value
-        """
-        return self.list_param
-
-    def schedule_tofit(self, schedule=0):
-        """
-        set schedule to true to decide if this fit  must be performed
-        """
-        self.schedule = schedule
-
-    def get_scheduled(self):
-        """
-        return true or false if a problem as being schedule for fitting
-        """
-        return self.schedule
-
-    def set_range(self, qmin=None, qmax=None):
-        """
-        set fitting range
-        :param qmin: minimum value to consider for the fit range
-        :param qmax: maximum value to consider for the fit range
-        """
-        self.qmin = qmin
-        self.qmax = qmax
-
-    def get_range(self):
-        """
-        :return: fitting range
-
-        """
-        return self.qmin, self.qmax
-
-    def clear_model_param(self):
-        """
-        clear constraint info
-        """
-        self.list_param = []
-
-    def set_fit_tab_caption(self, caption):
-        """
-        """
-        self.fit_tab_caption = str(caption)
-
-    def get_fit_tab_caption(self):
-        """
-        """
-        return self.fit_tab_caption
-
-    def set_graph_id(self, id):
-        """
-        Set graph id (from data_group_id at the time the graph produced)
-        """
-        self.graph_id = id
-
-    def get_graph_id(self):
-        """
-        Get graph_id
-        """
-        return self.graph_id
-
-    def set_result(self, result):
-        """
-        """
-        self.result = result
-
-    def get_result(self):
-        """
-        get result
-        """
-        return self.result

src/sas/sasgui/perspectives/fitting/fitting.py

@@ -23 +23 @@
 import traceback
 
+import bumps.options
+from bumps.gui.fit_dialog import show_fit_config
+try:
+    from bumps.gui.fit_dialog import EVT_FITTER_CHANGED
+except ImportError:
+    # CRUFT: bumps 0.7.5.8 and below
+    EVT_FITTER_CHANGED = None  # type: wx.PyCommandEvent
+
 from sas.sascalc.dataloader.loader import Loader
+from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit
+from sas.sascalc.fit.pagestate import Reader, PageState, SimFitPageState
+from sas.sascalc.fit import models
+
 from sas.sasgui.guiframe.dataFitting import Data2D
 from sas.sasgui.guiframe.dataFitting import Data1D
@@ -34 +46 @@
 from sas.sasgui.guiframe.plugin_base import PluginBase
 from sas.sasgui.guiframe.data_processor import BatchCell
-from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit
-from sas.sasgui.perspectives.fitting.console import ConsoleUpdate
-from sas.sasgui.perspectives.fitting.fitproblem import FitProblemDictionary
-from sas.sasgui.perspectives.fitting.fitpanel import FitPanel
-from sas.sasgui.perspectives.fitting.resultpanel import ResultPanel, PlotResultEvent
-
-from sas.sasgui.perspectives.fitting.fit_thread import FitThread
-from sas.sasgui.perspectives.fitting.pagestate import Reader
-from sas.sasgui.perspectives.fitting.fitpage import Chi2UpdateEvent
+from sas.sasgui.guiframe.gui_manager import MDIFrame
+from sas.sasgui.guiframe.documentation_window import DocumentationWindow
+
 from sas.sasgui.perspectives.calculator.model_editor import TextDialog
 from sas.sasgui.perspectives.calculator.model_editor import EditorWindow
-from sas.sasgui.guiframe.gui_manager import MDIFrame
-from sas.sasgui.guiframe.documentation_window import DocumentationWindow
-from sas.sasgui.perspectives.fitting.gpu_options import GpuOptions
-
-from . import models
+from sas.sasgui.perspectives.calculator.pyconsole import PyConsole
+
+from .fitting_widgets import DataDialog
+from .fit_thread import FitThread
+from .fitpage import Chi2UpdateEvent
+from .console import ConsoleUpdate
+from .fitproblem import FitProblemDictionary
+from .fitpanel import FitPanel
+from .model_thread import Calc1D, Calc2D
+from .resultpanel import ResultPanel, PlotResultEvent
+from .gpu_options import GpuOptions
 
 logger = logging.getLogger(__name__)
@@ -63 +75 @@
     ON_MAC = True
 
-import bumps.options
-from bumps.gui.fit_dialog import show_fit_config
-try:
-    from bumps.gui.fit_dialog import EVT_FITTER_CHANGED
-except ImportError:
-    # CRUFT: bumps 0.7.5.8 and below
-    EVT_FITTER_CHANGED = None  # type: wx.PyCommandEvent
 
 class Plugin(PluginBase):
@@ -240 +245 @@
         event_id = event.GetId()
         label = self.edit_menu.GetLabel(event_id)
-        from sas.sasgui.perspectives.calculator.pyconsole import PyConsole
         filename = os.path.join(models.find_plugins_dir(), label)
         frame = PyConsole(parent=self.parent, manager=self,
@@ -290 +294 @@
                         break
         except Exception:
-            import traceback; traceback.print_exc()
+            traceback.print_exc()
             msg = 'Delete Error: \nCould not delete the file; Check if in use.'
             wx.MessageBox(msg, 'Error')
@@ -300 +304 @@
         event_id = event.GetId()
         model_manager = models.ModelManager()
-        model_list = model_manager.get_model_name_list()
+        model_list = model_manager.composable_models()
         plug_dir = models.find_plugins_dir()
         textdial = TextDialog(None, self, wx.ID_ANY, 'Easy Sum/Multi(p1, p2) Editor',
@@ -340 +344 @@
             self.set_edit_menu_helper(self.parent, self.edit_custom_model)
             self.set_edit_menu_helper(self.parent, self.delete_custom_model)
-            temp = self.fit_panel.reset_pmodel_list()
-            if temp:
-                # Set the new plugin model list for all fit pages
-                for uid, page in self.fit_panel.opened_pages.iteritems():
-                    if hasattr(page, "formfactorbox"):
-                        page.model_list_box = temp
-                        current_val = page.formfactorbox.GetLabel()
-                        #if page.plugin_rbutton.GetValue():
-                        mod_cat = page.categorybox.GetStringSelection()
-                        if mod_cat == custom_model:
-                            #pos = page.formfactorbox.GetSelection()
-                            page._show_combox_helper()
-                            new_val = page.formfactorbox.GetLabel()
-                            if current_val != new_val and new_val != '':
-                                page.formfactorbox.SetLabel(new_val)
-                            else:
-                                page.formfactorbox.SetLabel(current_val)
-                        if hasattr(page, 'structurebox'):
-                            selected_name = page.structurebox.GetStringSelection()
-
-                            page.structurebox.Clear()
-                            page.initialize_combox()
-
-                            index = page.structurebox.FindString(selected_name)
-                            if index == -1:
-                                index = 0
-                            page.structurebox.SetSelection(index)
-                            page._on_select_model()
-        except:
+            new_pmodel_list = self.fit_panel.reset_pmodel_list()
+            if not new_pmodel_list:
+                return
+            # Set the new plugin model list for all fit pages
+            for uid, page in self.fit_panel.opened_pages.iteritems():
+                if hasattr(page, "formfactorbox"):
+                    page.model_list_box = new_pmodel_list
+                    mod_cat = page.categorybox.GetStringSelection()
+                    if mod_cat == custom_model:
+                        box = page.formfactorbox
+                        model_name = box.GetValue()
+                        model = (box.GetClientData(box.GetCurrentSelection())
+                                 if model_name else None)
+                        page._show_combox_helper()
+                        new_index = box.FindString(model_name)
+                        new_model = (box.GetClientData(new_index)
+                                     if new_index >= 0 else None)
+                        if new_index >= 0:
+                            box.SetStringSelection(model_name)
+                        else:
+                            box.SetStringSelection('')
+                        if model and new_model != model:
+                            page._on_select_model(keep_pars=True)
+                    if hasattr(page, "structurebox"):
+                        selected_name = page.structurebox.GetStringSelection()
+
+                        page.structurebox.Clear()
+                        page.initialize_combox()
+
+                        index = page.structurebox.FindString(selected_name)
+                        if index == -1:
+                            index = 0
+                        page.structurebox.SetSelection(index)
+                        page._on_select_model()
+        except Exception:
             logger.error("update_custom_combo: %s", sys.exc_value)
 
@@ -378 +388 @@
         #new_model_menu = wx.Menu()
         self.edit_model_menu.Append(wx_id, 'New Plugin Model',
-                                   'Add a new model function')
+                                    'Add a new model function')
         wx.EVT_MENU(owner, wx_id, self.make_new_model)
 
@@ -575 +585 @@
         else:
             if len(data_list) > MAX_NBR_DATA:
-                from fitting_widgets import DataDialog
                 dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA)
                 if dlg.ShowModal() == wx.ID_OK:
@@ -620 +629 @@
         : param datainfo: data
         """
-        from pagestate import PageState
-        from simfitpage import SimFitPageState
         if isinstance(state, PageState):
             state = state.clone()
             self.temp_state.append(state)
         elif isinstance(state, SimFitPageState):
-            state.load_from_save_state(self)
+            if self.fit_panel.sim_page is None:
+                self.fit_panel.add_sim_page()
+            self.fit_panel.sim_page.load_from_save_state(state)
         else:
             self.temp_state = []
@@ -661 +670 @@
                 self.parent.add_data(data_list={data.id: data})
                 wx.PostEvent(self.parent, NewPlotEvent(plot=data,
-                                        title=data.title))
+                             title=data.title))
                 #need to be fix later make sure we are sendind guiframe.data
                 #to panel
@@ -672 +681 @@
                 self.parent.add_data(data_list={data.id: data})
                 wx.PostEvent(self.parent, NewPlotEvent(plot=data,
-                                        title=data.title))
+                             title=data.title))
                 page = self.add_fit_page([data])
                 caption = page.window_caption
                 self.store_data(uid=page.uid, data_list=page.get_data_list(),
-                        caption=caption)
+                                caption=caption)
                 self.mypanels.append(page)
 
@@ -793 +802 @@
         """
         if item.find(".") >= 0:
-            param_names = re.split("\.", item)
+            param_names = re.split(r"\.", item)
             model_name = param_names[0]
             ##Assume max len is 3; eg., M0.radius.width
@@ -896 +905 @@
 
             self.draw_model(model=model, data=data, page_id=uid, smearer=smear,
-                enable1D=enable1D, enable2D=enable2D,
-                qmin=qmin, qmax=qmax, weight=weight)
+                            enable1D=enable1D, enable2D=enable2D,
+                            qmin=qmin, qmax=qmax, weight=weight)
 
     def draw_model(self, model, page_id, data=None, smearer=None,
@@ -940 +949 @@
             ## draw model 2D with no initial data
             self._draw_model2D(model=model,
-                                page_id=page_id,
-                                data=data,
-                                enable2D=enable2D,
-                                smearer=smearer,
-                                qmin=qmin,
-                                qmax=qmax,
-                                fid=fid,
-                                weight=weight,
-                                state=state,
-                                toggle_mode_on=toggle_mode_on,
-                                update_chisqr=update_chisqr,
-                                source=source)
+                               page_id=page_id,
+                               data=data,
+                               enable2D=enable2D,
+                               smearer=smearer,
+                               qmin=qmin,
+                               qmax=qmax,
+                               fid=fid,
+                               weight=weight,
+                               state=state,
+                               toggle_mode_on=toggle_mode_on,
+                               update_chisqr=update_chisqr,
+                               source=source)
 
     def onFit(self, uid):
@@ -960 +969 @@
         :param uid: id related to the panel currently calling this fit function.
         """
-        if uid is None: raise RuntimeError("no page to fit") # Should never happen
+        if uid is None:
+            raise RuntimeError("no page to fit") # Should never happen
 
         sim_page_uid = getattr(self.sim_page, 'uid', None)
@@ -994 +1004 @@
                     page = self.fit_panel.get_page_by_id(page_id)
                     self.set_fit_weight(uid=page.uid,
-                                     flag=page.get_weight_flag(),
-                                     is2d=page._is_2D())
+                                        flag=page.get_weight_flag(),
+                                        is2d=page._is_2D())
                     if not page.param_toFit:
                         msg = "No fitting parameters for %s" % page.window_caption
@@ -1019 +1029 @@
                             fitter = sim_fitter
                         self._add_problem_to_fit(fitproblem=fitproblem,
-                                             pars=pars,
-                                             fitter=fitter,
-                                             fit_id=fit_id)
+                                                 pars=pars,
+                                                 fitter=fitter,
+                                                 fit_id=fit_id)
                         fit_id += 1
                     list_page_id.append(page_id)
@@ -1068 +1078 @@
             ## Perform more than 1 fit at the time
             calc_fit = FitThread(handler=handler,
-                                    fn=fitter_list,
-                                    batch_inputs=batch_inputs,
-                                    batch_outputs=batch_outputs,
-                                    page_id=list_page_id,
-                                    updatefn=handler.update_fit,
-                                    completefn=self._fit_completed)
+                                 fn=fitter_list,
+                                 batch_inputs=batch_inputs,
+                                 batch_outputs=batch_outputs,
+                                 page_id=list_page_id,
+                                 updatefn=handler.update_fit,
+                                 completefn=self._fit_completed)
         #self.fit_thread_list[current_page_id] = calc_fit
         self.fit_thread_list[uid] = calc_fit
@@ -1134 +1144 @@
                 evt = StatusEvent(status=msg, info="warning")
                 wx.PostEvent(self.parent, evt)
-        except:
+        except Exception:
             msg = "Creating Fit page: %s" % sys.exc_value
             wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
@@ -1158 +1168 @@
                     group_id = str(page.uid) + " Model1D"
                     wx.PostEvent(self.parent,
-                             NewPlotEvent(group_id=group_id,
-                                               action="delete"))
+                                 NewPlotEvent(group_id=group_id,
+                                              action="delete"))
                     self.parent.update_data(prev_data=theory_data,
-                                             new_data=data)
+                                            new_data=data)
             else:
                 if theory_data is not None:
@@ -1167 +1177 @@
                     data.group_id = theory_data.group_id
                     wx.PostEvent(self.parent,
-                             NewPlotEvent(group_id=group_id,
-                                               action="delete"))
+                                 NewPlotEvent(group_id=group_id,
+                                              action="delete"))
                     self.parent.update_data(prev_data=theory_data,
-                                             new_data=data)
+                                            new_data=data)
         self.store_data(uid=page.uid, data_list=page.get_data_list(),
                         caption=page.window_caption)
@@ -1479 +1489 @@
         if "Data" not in batch_outputs.keys():
             batch_outputs["Data"] = []
-        from sas.sasgui.guiframe.data_processor import BatchCell
         cell = BatchCell()
         cell.label = data.name
@@ -1579 +1588 @@
                     except KeyboardInterrupt:
                         fit_msg += "\nSingular point: Fitting stopped."
-                    except:
+                    except Exception:
                         fit_msg += "\nSingular point: Fitting error occurred."
                 if fit_msg:
-                   evt = StatusEvent(status=fit_msg, info="warning", type="stop")
-                   wx.PostEvent(self.parent, evt)
-
-        except:
+                    evt = StatusEvent(status=fit_msg, info="warning", type="stop")
+                    wx.PostEvent(self.parent, evt)
+
+        except Exception:
             msg = ("Fit completed but the following error occurred: %s"
                    % sys.exc_value)
-            #import traceback; msg = "\n".join((traceback.format_exc(), msg))
+            #msg = "\n".join((traceback.format_exc(), msg))
             evt = StatusEvent(status=msg, info="warning", type="stop")
             wx.PostEvent(self.parent, evt)
@@ -1743 +1752 @@
                                                   fid=data.id)
         self.parent.update_theory(data_id=data.id, theory=new_plot,
-                                   state=state)
+                                  state=state)
         return new_plot
 
@@ -1767 +1776 @@
         # Create the new theories
         if unsmeared_model is not None:
-            unsmeared_model_plot = self.create_theory_1D(x, unsmeared_model, 
+            unsmeared_model_plot = self.create_theory_1D(x, unsmeared_model,
                                   page_id, model, data, state,
                                   data_description=model.name + " unsmeared",
@@ -1774 +1783 @@
 
             if unsmeared_data is not None and unsmeared_error is not None:
-                unsmeared_data_plot = self.create_theory_1D(x, unsmeared_data, 
+                unsmeared_data_plot = self.create_theory_1D(x, unsmeared_data,
                                       page_id, model, data, state,
                                       data_description="Data unsmeared",
@@ -1792 +1801 @@
             plots_to_update.append(pq_plot)
         # Update the P(Q), S(Q) and unsmeared theory plots if they exist
-        wx.PostEvent(self.parent, NewPlotEvent(plots=plots_to_update, 
+        wx.PostEvent(self.parent, NewPlotEvent(plots=plots_to_update,
                                               action='update'))
 
@@ -1808 +1817 @@
 
         self.page_finder[page_id].set_theory_data(data=new_plot,
-                                                      fid=data.id)
+                                                  fid=data.id)
         if toggle_mode_on:
             wx.PostEvent(self.parent,
                          NewPlotEvent(group_id=str(page_id) + " Model2D",
-                                          action="Hide"))
+                                      action="Hide"))
         else:
             if update_chisqr:
-                wx.PostEvent(current_pg,
-                             Chi2UpdateEvent(output=self._cal_chisqr(
-                                                                data=data,
-                                                                fid=fid,
-                                                                weight=weight,
-                                                                page_id=page_id,
-                                                                index=index)))
+                output = self._cal_chisqr(data=data,
+                                          fid=fid,
+                                          weight=weight,
+                                          page_id=page_id,
+                                          index=index)
+                wx.PostEvent(current_pg, Chi2UpdateEvent(output=output))
             else:
                 self._plot_residuals(page_id=page_id, data=data, fid=fid,
@@ -1829 +1837 @@
             logger.error("Using the present parameters the model does not return any finite value. ")
             msg = "Computing Error: Model did not return any finite value."
-            wx.PostEvent(self.parent, StatusEvent(status = msg, info="error"))
+            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
         else:
             msg = "Computation  completed!"
@@ -1854 +1862 @@
 
     def _complete2D(self, image, data, model, page_id, elapsed, index, qmin,
-                qmax, fid=None, weight=None, toggle_mode_on=False, state=None,
-                     update_chisqr=True, source='model', plot_result=True):
+                    qmax, fid=None, weight=None, toggle_mode_on=False, state=None,
+                    update_chisqr=True, source='model', plot_result=True):
         """
         Complete get the result of modelthread and create model 2D
@@ -1896 +1904 @@
                                                   fid=data.id)
         self.parent.update_theory(data_id=data.id,
-                                       theory=new_plot,
-                                       state=state)
+                                  theory=new_plot,
+                                  state=state)
         current_pg = self.fit_panel.get_page_by_id(page_id)
         title = new_plot.title
         if not source == 'fit' and plot_result:
-            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,
-                                               title=title))
+            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title))
         if toggle_mode_on:
             wx.PostEvent(self.parent,
-                             NewPlotEvent(group_id=str(page_id) + " Model1D",
-                                               action="Hide"))
+                         NewPlotEvent(group_id=str(page_id) + " Model1D",
+                                      action="Hide"))
         else:
             # Chisqr in fitpage
             if update_chisqr:
-                wx.PostEvent(current_pg,
-                             Chi2UpdateEvent(output=self._cal_chisqr(data=data,
-                                                                    weight=weight,
-                                                                    fid=fid,
-                                                         page_id=page_id,
-                                                         index=index)))
+                output = self._cal_chisqr(data=data,
+                                          weight=weight,
+                                          fid=fid,
+                                          page_id=page_id,
+                                          index=index)
+                wx.PostEvent(current_pg, Chi2UpdateEvent(output=output))
             else:
                 self._plot_residuals(page_id=page_id, data=data, fid=fid,
-                                      index=index, weight=weight)
+                                     index=index, weight=weight)
 
         if not number_finite:
             logger.error("Using the present parameters the model does not return any finite value. ")
             msg = "Computing Error: Model did not return any finite value."
-            wx.PostEvent(self.parent, StatusEvent(status = msg, info="error"))
+            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error"))
         else:
             msg = "Computation  completed!"
@@ -1939 +1946 @@
                       weight=None,
                       toggle_mode_on=False,
-                       update_chisqr=True, source='model'):
+                      update_chisqr=True, source='model'):
         """
         draw model in 2D
@@ -1954 +1961 @@
             return None
         try:
-            from model_thread import Calc2D
             ## If a thread is already started, stop it
             if (self.calc_2D is not None) and self.calc_2D.isrunning():
@@ -1986 +1992 @@
     def _draw_model1D(self, model, page_id, data,
                       qmin, qmax, smearer=None,
-                state=None,
-                weight=None,
-                fid=None,
-                toggle_mode_on=False, update_chisqr=True, source='model',
-                enable1D=True):
+                      state=None, weight=None, fid=None,
+                      toggle_mode_on=False, update_chisqr=True, source='model',
+                      enable1D=True):
         """
         Draw model 1D from loaded data1D
@@ -2001 +2005 @@
             return
         try:
-            from model_thread import Calc1D
             ## If a thread is already started, stop it
             if (self.calc_1D is not None) and self.calc_1D.isrunning():

src/sas/sasgui/perspectives/fitting/model_thread.py

@@ -1 +1 @@
 """
-    Calculation thread for modeling
+Calculation thread for modeling
 """
 
 import time
+import math
+
 import numpy as np
-import math
+
 from sas.sascalc.data_util.calcthread import CalcThread
 from sas.sascalc.fit.MultiplicationModel import MultiplicationModel
@@ -28 +30 @@
                  worktime=0.04,
                  exception_handler=None,
-                 ):
+                ):
         CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime,
                             exception_handler=exception_handler)
@@ -57 +59 @@
         if self.qmax is None:
             if self.data is not None:
-                newx = math.pow(max(math.fabs(self.data.xmax),
-                                   math.fabs(self.data.xmin)), 2)
-                newy = math.pow(max(math.fabs(self.data.ymax),
-                                   math.fabs(self.data.ymin)), 2)
-                self.qmax = math.sqrt(newx + newy)
+                newx = max(math.fabs(self.data.xmax), math.fabs(self.data.xmin))
+                newy = max(math.fabs(self.data.ymax), math.fabs(self.data.ymin))
+                self.qmax = math.sqrt(newx**2 + newy**2)
 
         if self.data is None:
@@ -68 +68 @@
 
         # Define matrix where data will be plotted
-        radius = np.sqrt((self.data.qx_data * self.data.qx_data) + \
-                    (self.data.qy_data * self.data.qy_data))
+        radius = np.sqrt(self.data.qx_data**2 + self.data.qy_data**2)
 
         # For theory, qmax is based on 1d qmax
         # so that must be mulitified by sqrt(2) to get actual max for 2d
         index_model = (self.qmin <= radius) & (radius <= self.qmax)
-        index_model = index_model & self.data.mask
-        index_model = index_model & np.isfinite(self.data.data)
+        index_model &= self.data.mask
+        index_model &= np.isfinite(self.data.data)
 
         if self.smearer is not None:
@@ -101 +100 @@
         elapsed = time.time() - self.starttime
         self.complete(image=output,
-                       data=self.data,
-                       page_id=self.page_id,
-                       model=self.model,
-                       state=self.state,
-                       toggle_mode_on=self.toggle_mode_on,
-                       elapsed=elapsed,
-                       index=index_model,
-                       fid=self.fid,
-                       qmin=self.qmin,
-                       qmax=self.qmax,
-                       weight=self.weight,
-                       #qstep=self.qstep,
-                       update_chisqr=self.update_chisqr,
-                       source=self.source)
+                      data=self.data,
+                      page_id=self.page_id,
+                      model=self.model,
+                      state=self.state,
+                      toggle_mode_on=self.toggle_mode_on,
+                      elapsed=elapsed,
+                      index=index_model,
+                      fid=self.fid,
+                      qmin=self.qmin,
+                      qmax=self.qmax,
+                      weight=self.weight,
+                      #qstep=self.qstep,
+                      update_chisqr=self.update_chisqr,
+                      source=self.source)
 
 
@@ -138 +137 @@
                  worktime=0.01,
                  exception_handler=None,
-                 ):
+                ):
         """
         """
@@ -193 +192 @@
                                                         * unsmeared_output[first_bin:last_bin+1]\
                                                         / output[first_bin:last_bin+1]
-                unsmeared_output=unsmeared_output[index]
-                unsmeared_data=unsmeared_data[index]
-                unsmeared_error=unsmeared_error
+                unsmeared_output = unsmeared_output[index]
+                unsmeared_data = unsmeared_data[index]
+                unsmeared_error = unsmeared_error
         else:
             output[index] = self.model.evalDistribution(self.data.x[index])
@@ -243 +242 @@
     class CalcCommandline:
         def __init__(self, n=20000):
-            #print thread.get_ident()
-            from sas.models.CylinderModel import CylinderModel
-
-            model = CylinderModel()
-
-
-            print model.runXY([0.01, 0.02])
+            #print(thread.get_ident())
+
+            from sasmodels.sasview_model import _make_standard_model
+            cylinder = _make_standard_model('cylinder')
+            model = cylinder()
+
+            print(model.runXY([0.01, 0.02]))
 
             qmax = 0.01
@@ -258 +257 @@
             y = numpy.arange(-qmax, qmax+qstep*0.01, qstep)
 
-
             calc_thread_2D = Calc2D(x, y, None, model.clone(),None,
                                     -qmax, qmax,qstep,
-                                            completefn=self.complete,
-                                            updatefn=self.update ,
-                                            yieldtime=0.0)
+                                    completefn=self.complete,
+                                    updatefn=self.update ,
+                                    yieldtime=0.0)
 
             calc_thread_2D.queue()
@@ -272 +270 @@
 
         def update(self,output):
-            print "update"
+            print("update")
 
         def complete(self, image, data, model, elapsed, qmin, qmax,index, qstep ):
-            print "complete"
+            print("complete")
             self.done = True
 

src/sas/sasgui/perspectives/fitting/report_dialog.py

@@ -38 +38 @@
         # number of images of plot
         self.nimages = len(self.report_list[2])
-
-        if self.report_list[2] is not None:
-            # put image path in the report string
-            if len(self.report_list[2]) == 1:
-                self.report_html = self.report_list[0] % \
-                                    "memory:img_fit0.png"
-            elif len(self.report_list[2]) == 2:
-                self.report_html = self.report_list[0] % \
-                                    ("memory:img_fit0.png",
-                                     "memory:img_fit1.png")
-            # allows up to three images
-            else:
-                self.report_html = self.report_list[0] % \
-                                    ("memory:img_fit0.png",
-                                     "memory:img_fit1.png",
-                                     "memory:img_fit2.png")
-        else:
-            self.report_html = self.report_list[0]
+        self.report_html = self.report_list[0]
         # layout
         self._setup_layout()
@@ -105 +88 @@
             elif self.nimages == 3:
                 html = report_frame % (str(pic_fname[0]), str(pic_fname[1]),
-                                          str(pic_fname[2]))
+                                       str(pic_fname[2]))
 
             # make/open file in case of absence
@@ -118 +101 @@
                     #Windows
                     os.startfile(str(fName))
-                except:
+                except Exception:
                     try:
                         #Mac
                         os.system("open %s" % fName)
-                    except:
+                    except Exception:
                         #DO not open
                         pass