Diff [d76c43ad96fd212e9d871589ddccf6da0f78ff08:69363c7bf1d843f241ce1e9678099af03c373d9b] for / – SasView

sasview/sasview.py

                       r3b0f8cc
         # to ensure a complete Windows executable build.
+        # Rebuild .sasview/categories.json.  This triggers a load of sasmodels
+        # and all the plugins.
+        try:
+            from sas.sascalc.fit.models import ModelManager
+            from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller
+            model_list = ModelManager().cat_model_list()
+            CategoryInstaller.check_install(model_list=model_list)
+        except Exception:
+            logger.error("%s: could not load SasView models")
+            logger.error(traceback.format_exc())
         # Fitting perspective
         try:

src/sas/sascalc/fit/AbstractFitEngine.py

-                      ra1b8fee
+                      r50fcb09
                that will smear the theory data (slit smearing or resolution
                smearing) when set.
             The proper way to set the smearing object would be to
             do the following: ::
                 from sas.sascalc.data_util.qsmearing import smear_selection
+                from sas.sascalc.fit.qsmearing import smear_selection
                 smearer = smear_selection(some_data)
                 fitdata1d = FitData1D( x= [1,3,..,],
 …
                                         dx=None,
                                         dy=[1,2...], smearer= smearer)
             :Note: that some_data _HAS_ to be of
                 class DataLoader.data_info.Data1D
                 Setting it back to None will turn smearing off.
         """
         Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy, lam=lam, dlam=dlam)
 …
         ## Max Q-value
         self.qmax = max(self.x)
         # Range used for input to smearing
         self._qmin_unsmeared = self.qmin
 …
         self.idx_unsmeared = (self.x >= self._qmin_unsmeared) \
                             & (self.x <= self._qmax_unsmeared)
     def set_fit_range(self, qmin=None, qmax=None):
         """ to set the fit range"""
 …
         self._qmin_unsmeared = self.qmin
         self._qmax_unsmeared = self.qmax
         self._first_unsmeared_bin = 0
         self._last_unsmeared_bin = len(self.x) - 1
         if self.smearer is not None:
             self._first_unsmeared_bin, self._last_unsmeared_bin = \
 …
             self._qmin_unsmeared = self.x[self._first_unsmeared_bin]
             self._qmax_unsmeared = self.x[self._last_unsmeared_bin]
         # Identify the bin range for the unsmeared and smeared spaces
         self.idx = (self.x >= self.qmin) & (self.x <= self.qmax)
 …
         """
             Compute residuals.
             If self.smearer has been set, use if to smear
             the data before computing chi squared.
             :param fn: function that return model value
             :return: residuals
         """
 …
         fx = np.zeros(len(self.x))
         fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared])
         ## Smear theory data
         if self.smearer is not None:
 …
             raise RuntimeError, msg
         return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx]
     def residuals_deriv(self, model, pars=[]):
         """
             :return: residuals derivatives .
             :note: in this case just return empty array
+            :note: in this case just return empty array
         """
         return []
 …
         x_max = max(math.fabs(sas_data2d.xmin), math.fabs(sas_data2d.xmax))
         y_max = max(math.fabs(sas_data2d.ymin), math.fabs(sas_data2d.ymax))
         ## fitting range
         if qmin is None:
 …
             self.res_err_data = copy.deepcopy(self.err_data)
         #self.res_err_data[self.res_err_data==0]=1
         self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         # Note: mask = True: for MASK while mask = False for NOT to mask
         self.idx = ((self.qmin <= self.radius) &\
 …
         return res, gn
     def residuals_deriv(self, model, pars=[]):
         """
         :return: residuals derivatives .
         :note: in this case just return empty array
         """
         return []
 class FitAbort(Exception):
     """
 …
         self.fit_arrange_dict = {}
         self.fitter_id = None
     def set_model(self, model, id, pars=[], constraints=[], data=None):
         """
         set a model on a given  in the fit engine.
         :param model: sas.models type
+        :param model: sas.models type
         :param id: is the key of the fitArrange dictionary where model is saved as a value
         :param pars: the list of parameters to fit
         :param constraints: list of
+        :param pars: the list of parameters to fit
+        :param constraints: list of
             tuple (name of parameter, value of parameters)
             the value of parameter must be a string to constraint 2 different
             parameters.
             Example:
+            Example:
             we want to fit 2 model M1 and M2 both have parameters A and B.
             constraints can be ``constraints = [(M1.A, M2.B+2), (M1.B= M2.A *5),...,]``
         :note: pars must contains only name of existing model's parameters
         """
         if not pars:
 …
         in a FitArrange object and adds that object in a dictionary
         with key id.
         :param data: data added
         :param id: unique key corresponding to a fitArrange object with data
 …
                                  dx=data.dx, dy=data.dy, smearer=smearer)
         fitdata.sas_data = data
         fitdata.set_fit_range(qmin=qmin, qmax=qmax)
         #A fitArrange is already created but contains model only at id
 …
             fitproblem.add_data(fitdata)
             self.fit_arrange_dict[id] = fitproblem
     def get_model(self, id):
         """
         :param id: id is key in the dictionary containing the model to return
         :return:  a model at this id or None if no FitArrange element was
             created with this id
 …
         else:
             return None
     def remove_fit_problem(self, id):
         """remove   fitarrange in id"""
         if id in self.fit_arrange_dict:
             del self.fit_arrange_dict[id]
     def select_problem_for_fit(self, id, value):
         """
         select a couple of model and data at the id position in dictionary
         and set in self.selected value to value
         :param value: the value to allow fitting.
                 can only have the value one or zero
 …
         if id in self.fit_arrange_dict:
             self.fit_arrange_dict[id].set_to_fit(value)
     def get_problem_to_fit(self, id):
         """
         return the self.selected value of the fit problem of id
         :param id: the id of the problem
         """
         if id in self.fit_arrange_dict:
             self.fit_arrange_dict[id].get_to_fit()
 class FitArrange:
     def __init__(self):
 …
         to perform the Fit.FitArrange must contain exactly one model
         and at least one data for the fit to be performed.
         model: the model selected by the user
         Ldata: a list of data what the user wants to fit
         """
         self.model = None
 …
         """
         set_model save a copy of the model
         :param model: the model being set
         """
         self.model = model
     def add_data(self, data):
         """
         add_data fill a self.data_list with data to fit
         :param data: Data to add in the list
         """
         if not data in self.data_list:
             self.data_list.append(data)
     def get_model(self):
         """
 …
         """
         return self.model
     def get_data(self):
         """
 …
         """
         return self.data_list[0]
     def remove_data(self, data):
         """
         Remove one element from the list
         :param data: Data to remove from data_list
         """
         if data in self.data_list:
             self.data_list.remove(data)
     def set_to_fit(self, value=0):
         """
         set self.selected to 0 or 1  for other values raise an exception
         :param value: integer between 0 or 1
         """
         self.selected = value
     def get_to_fit(self):
         """
 …
         if self.model is not None and self.data is not None:
             self.inputs = [(self.model, self.data)]
     def set_model(self, model):
         """
         """
         self.model = model
     def set_fitness(self, fitness):
         """
         """
         self.fitness = fitness
     def __str__(self):
         """
 …
         msg = [msg1, msg3] + msg2
         return "\n".join(msg)
     def print_summary(self):
         """

src/sas/sascalc/fit/BumpsFitting.py

-                      r9a5097c
+                      r1386b2f
     def get_fitter():
         return FIT_CONFIG.selected_fitter, FIT_CONFIG.selected_values
 except:
+except ImportError:
     # CRUFT: Bumps changed its handling of fit options around 0.7.5.6
     # Default bumps to use the Levenberg-Marquardt optimizer
 …
         header = "=== Steps: %s  chisq: %s  ETA: %s\n"%(step, chisq, time)
         parameters = ["%15s: %-10.3g%s"%(k,v,("\n" if i%3==2 else " | "))
                       for i,(k,v) in enumerate(zip(pars,history.point[0]))]
+                      for i, (k, v) in enumerate(zip(pars, history.point[0]))]
         self.msg = "".join([header]+parameters)
 …
         self.handler.set_result(Progress(history, self.max_step, self.pars, self.dof))
         self.handler.progress(history.step[0], self.max_step)
         if len(history.step)>1 and history.step[1] > history.step[0]:
+        if len(history.step) > 1 and history.step[1] > history.step[0]:
             self.handler.improvement()
         self.handler.update_fit()
 …
         try:
             p = history.population_values[0]
             n,p = len(p), np.sort(p)
             QI,Qmid, = int(0.2*n),int(0.5*n)
             self.convergence.append((best, p[0],p[QI],p[Qmid],p[-1-QI],p[-1]))
         except:
             self.convergence.append((best, best,best,best,best,best))
+            n, p = len(p), np.sort(p)
+            QI, Qmid = int(0.2*n), int(0.5*n)
+            self.convergence.append((best, p[0], p[QI], p[Qmid], p[-1-QI], p[-1]))
+        except Exception:
+            self.convergence.append((best, best, best, best, best, best))
 …
     def _reset_pars(self, names, values):
         for k,v in zip(names, values):
+        for k, v in zip(names, values):
             self._pars[k].value = v
 …
         self._pars = {}
         for k in self.model.getParamList():
             name = ".".join((self.name,k))
+            name = ".".join((self.name, k))
             value = self.model.getParam(k)
             bounds = self.model.details.get(k,["",None,None])[1:3]
+            bounds = self.model.details.get(k, ["", None, None])[1:3]
             self._pars[k] = parameter.Parameter(value=value, bounds=bounds,
                                                 fixed=True, name=name)
 …
     def _init_pars(self, kw):
         for k,v in kw.items():
+        for k, v in kw.items():
             # dispersion parameters initialized with _field instead of .field
+            if k.endswith('_width'): k = k[:-6]+'.width'
+            elif k.endswith('_npts'): k = k[:-5]+'.npts'
+            elif k.endswith('_nsigmas'): k = k[:-7]+'.nsigmas'
+            elif k.endswith('_type'): k = k[:-5]+'.type'
+            if k.endswith('_width'):
+                k = k[:-6]+'.width'
+            elif k.endswith('_npts'):
+                k = k[:-5]+'.npts'
+            elif k.endswith('_nsigmas'):
+                k = k[:-7]+'.nsigmas'
+            elif k.endswith('_type'):
+                k = k[:-5]+'.type'
             if k not in self._pars:
                 formatted_pars = ", ".join(sorted(self._pars.keys()))
 …
             elif isinstance(v, parameter.BaseParameter):
                 self._pars[k] = v
             elif isinstance(v, (tuple,list)):
+            elif isinstance(v, (tuple, list)):
                 low, high = v
                 self._pars[k].value = (low+high)/2
                 self._pars[k].range(low,high)
+                self._pars[k].range(low, high)
             else:
                 self._pars[k].value = v
 …
         Flag a set of parameters as fitted parameters.
         """
         for k,p in self._pars.items():
+        for k, p in self._pars.items():
             p.fixed = (k not in param_list or k in self.constraints)
         self.fitted_par_names = [k for k in param_list if k not in self.constraints]
 …
     def update(self):
         for k,v in self._pars.items():
+        for k, v in self._pars.items():
             #print "updating",k,v,v.value
             self.model.setParam(k,v.value)
+            self.model.setParam(k, v.value)
         self._dirty = True
 …
             symtab = dict((".".join((M.name, k)), p)
                           for M in self.models
                           for k,p in M.parameters().items())
+                          for k, p in M.parameters().items())
             self.update = compile_constraints(symtab, exprs)
         else:
 …
                                           np.NaN*np.ones(len(fitness.computed_pars))))
                 R.pvec = np.hstack((result['value'][fitted_index],
                                       [p.value for p in fitness.computed_pars]))
+                                    [p.value for p in fitness.computed_pars]))
                 R.fitness = np.sum(R.residuals**2)/(fitness.numpoints() - len(fitted_index))
             else:
                 R.stderr = np.NaN*np.ones(len(param_list))
                 R.pvec = np.asarray( [p.value for p in fitness.fitted_pars+fitness.computed_pars])
+                R.pvec = np.asarray([p.value for p in fitness.fitted_pars+fitness.computed_pars])
                 R.fitness = np.NaN
             R.convergence = result['convergence']
 …
     steps = options.get('steps', 0)
     if steps == 0:
         pop = options.get('pop',0)*len(problem._parameters)
+        pop = options.get('pop', 0)*len(problem._parameters)
         samples = options.get('samples', 0)
         steps = (samples+pop-1)/pop if pop != 0 else samples
 …
     fitdriver = fitters.FitDriver(fitclass, problem=problem,
                                   abort_test=abort_test, **options)
     omp_threads = int(os.environ.get('OMP_NUM_THREADS','0'))
+    omp_threads = int(os.environ.get('OMP_NUM_THREADS', '0'))
     mapper = MPMapper if omp_threads == 1 else SerialMapper
     fitdriver.mapper = mapper.start_mapper(problem, None)
 …
     convergence_list = options['monitors'][-1].convergence
     convergence = (2*np.asarray(convergence_list)/problem.dof
                    if convergence_list else np.empty((0,1),'d'))
+                   if convergence_list else np.empty((0, 1), 'd'))
     success = best is not None
 …
         'errors': '\n'.join(errors),
+        }

src/sas/sascalc/pr/fit/AbstractFitEngine.py

-                      ra1b8fee
+                      r50fcb09
                that will smear the theory data (slit smearing or resolution
                smearing) when set.
             The proper way to set the smearing object would be to
             do the following: ::
                 from sas.sascalc.data_util.qsmearing import smear_selection
+                from sas.sascalc.fit.qsmearing import smear_selection
                 smearer = smear_selection(some_data)
                 fitdata1d = FitData1D( x= [1,3,..,],
 …
                                         dx=None,
                                         dy=[1,2...], smearer= smearer)
             :Note: that some_data _HAS_ to be of
                 class DataLoader.data_info.Data1D
                 Setting it back to None will turn smearing off.
         """
         Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy)
 …
         ## Max Q-value
         self.qmax = max(self.x)
         # Range used for input to smearing
         self._qmin_unsmeared = self.qmin
 …
         self.idx_unsmeared = (self.x >= self._qmin_unsmeared) \
                             & (self.x <= self._qmax_unsmeared)
     def set_fit_range(self, qmin=None, qmax=None):
         """ to set the fit range"""
 …
         self._qmin_unsmeared = self.qmin
         self._qmax_unsmeared = self.qmax
         self._first_unsmeared_bin = 0
         self._last_unsmeared_bin = len(self.x) - 1
         if self.smearer is not None:
             self._first_unsmeared_bin, self._last_unsmeared_bin = \
 …
             self._qmin_unsmeared = self.x[self._first_unsmeared_bin]
             self._qmax_unsmeared = self.x[self._last_unsmeared_bin]
         # Identify the bin range for the unsmeared and smeared spaces
         self.idx = (self.x >= self.qmin) & (self.x <= self.qmax)
 …
         """
             Compute residuals.
             If self.smearer has been set, use if to smear
             the data before computing chi squared.
             :param fn: function that return model value
             :return: residuals
         """
 …
         fx = np.zeros(len(self.x))
         fx[self.idx_unsmeared] = fn(self.x[self.idx_unsmeared])
         ## Smear theory data
         if self.smearer is not None:
 …
             raise RuntimeError, msg
         return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx]
     def residuals_deriv(self, model, pars=[]):
         """
             :return: residuals derivatives .
             :note: in this case just return empty array
+            :note: in this case just return empty array
         """
         return []
 …
         x_max = max(math.fabs(sas_data2d.xmin), math.fabs(sas_data2d.xmax))
         y_max = max(math.fabs(sas_data2d.ymin), math.fabs(sas_data2d.ymax))
         ## fitting range
         if qmin is None:
 …
             self.res_err_data = copy.deepcopy(self.err_data)
         #self.res_err_data[self.res_err_data==0]=1
         self.radius = np.sqrt(self.qx_data**2 + self.qy_data**2)
         # Note: mask = True: for MASK while mask = False for NOT to mask
         self.idx = ((self.qmin <= self.radius) &\
 …
         return res, gn
     def residuals_deriv(self, model, pars=[]):
         """
         :return: residuals derivatives .
         :note: in this case just return empty array
         """
         return []
 class FitAbort(Exception):
     """
 …
         self.fit_arrange_dict = {}
         self.fitter_id = None
     def set_model(self, model, id, pars=[], constraints=[], data=None):
         """
         set a model on a given  in the fit engine.
         :param model: sas.models type
+        :param model: sas.models type
         :param id: is the key of the fitArrange dictionary where model is saved as a value
         :param pars: the list of parameters to fit
         :param constraints: list of
+        :param pars: the list of parameters to fit
+        :param constraints: list of
             tuple (name of parameter, value of parameters)
             the value of parameter must be a string to constraint 2 different
             parameters.
             Example:
+            Example:
             we want to fit 2 model M1 and M2 both have parameters A and B.
             constraints can be ``constraints = [(M1.A, M2.B+2), (M1.B= M2.A *5),...,]``
         :note: pars must contains only name of existing model's parameters
         """
         if not pars:
 …
         in a FitArrange object and adds that object in a dictionary
         with key id.
         :param data: data added
         :param id: unique key corresponding to a fitArrange object with data
 …
                                  dx=data.dx, dy=data.dy, smearer=smearer)
         fitdata.sas_data = data
         fitdata.set_fit_range(qmin=qmin, qmax=qmax)
         #A fitArrange is already created but contains model only at id
 …
             fitproblem.add_data(fitdata)
             self.fit_arrange_dict[id] = fitproblem
     def get_model(self, id):
         """
         :param id: id is key in the dictionary containing the model to return
         :return:  a model at this id or None if no FitArrange element was
             created with this id
 …
         else:
             return None
     def remove_fit_problem(self, id):
         """remove   fitarrange in id"""
         if id in self.fit_arrange_dict:
             del self.fit_arrange_dict[id]
     def select_problem_for_fit(self, id, value):
         """
         select a couple of model and data at the id position in dictionary
         and set in self.selected value to value
         :param value: the value to allow fitting.
                 can only have the value one or zero
 …
         if id in self.fit_arrange_dict:
             self.fit_arrange_dict[id].set_to_fit(value)
     def get_problem_to_fit(self, id):
         """
         return the self.selected value of the fit problem of id
         :param id: the id of the problem
         """
         if id in self.fit_arrange_dict:
             self.fit_arrange_dict[id].get_to_fit()
 class FitArrange:
     def __init__(self):
 …
         to perform the Fit.FitArrange must contain exactly one model
         and at least one data for the fit to be performed.
         model: the model selected by the user
         Ldata: a list of data what the user wants to fit
         """
         self.model = None
 …
         """
         set_model save a copy of the model
         :param model: the model being set
         """
         self.model = model
     def add_data(self, data):
         """
         add_data fill a self.data_list with data to fit
         :param data: Data to add in the list
         """
         if not data in self.data_list:
             self.data_list.append(data)
     def get_model(self):
         """
 …
         """
         return self.model
     def get_data(self):
         """
 …
         """
         return self.data_list[0]
     def remove_data(self, data):
         """
         Remove one element from the list
         :param data: Data to remove from data_list
         """
         if data in self.data_list:
             self.data_list.remove(data)
     def set_to_fit(self, value=0):
         """
         set self.selected to 0 or 1  for other values raise an exception
         :param value: integer between 0 or 1
         """
         self.selected = value
     def get_to_fit(self):
         """
 …
         if self.model is not None and self.data is not None:
             self.inputs = [(self.model, self.data)]
     def set_model(self, model):
         """
         """
         self.model = model
     def set_fitness(self, fitness):
         """
         """
         self.fitness = fitness
     def __str__(self):
         """
 …
         msg = [msg1, msg3] + msg2
         return "\n".join(msg)
     def print_summary(self):
         """

src/sas/sascalc/realspace/VolumeCanvas.py

-                      r235f514
+                      r98e3f24
     Simulation canvas for real-space simulation of SAS scattering intensity.
     The user can create an arrangement of basic shapes and estimate I(q) and
     I(q_x, q_y). Error estimates on the simulation are also available.
+    I(q_x, q_y). Error estimates on the simulation are also available.
     Example:
     import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas
     canvas = VolumeCanvas.VolumeCanvas()
     canvas.setParam('lores_density', 0.01)
     sphere = SphereDescriptor()
     handle = canvas.addObject(sphere)
 …
     output, error = canvas.getIqError(q=0.1)
     output, error = canvas.getIq2DError(0.1, 0.1)
     or alternatively:
     iq = canvas.run(0.1)
     i2_2D = canvas.run([0.1, 1.57])
 """
 from sas.models.BaseComponent import BaseComponent
+from sas.sascalc.calculator.BaseComponent import BaseComponent
 from sas.sascalc.simulation.pointsmodelpy import pointsmodelpy
 from sas.sascalc.simulation.geoshapespy import geoshapespy
 …
 import os.path, math
 class ShapeDescriptor:
+class ShapeDescriptor(object):
     """
         Class to hold the information about a shape
         The descriptor holds a dictionary of parameters.
         Note: if shape parameters are accessed directly
         from outside VolumeCanvas. The getPr method
         should be called before evaluating I(q).
     """
     def __init__(self):
 …
         self.params['is_lores'] = True
         self.params['order'] = 0
     def create(self):
         """
 …
         z0 = self.params["center"][2]
         geoshapespy.set_center(self.shapeObject, x0, y0, z0)
         # Set orientation
         x0 = self.params["orientation"][0]
 …
         z0 = self.params["orientation"][2]
         geoshapespy.set_orientation(self.shapeObject, x0, y0, z0)
 class SphereDescriptor(ShapeDescriptor):
     """
         Descriptor for a sphere
         The parameters are:
             - radius [Angstroem] [default = 20 A]
             - Contrast [A-2] [default = 1 A-2]
     """
     def __init__(self):
         """
             Initialization
         """
+        """
         ShapeDescriptor.__init__(self)
         # Default parameters
         self.params["type"]   = "sphere"
+        self.params["type"] = "sphere"
         # Radius of the sphere
         self.params["radius"] = 20.0
 …
         self.shapeObject = geoshapespy.new_sphere(\
             self.params["radius"])
         ShapeDescriptor.create(self)
+        ShapeDescriptor.create(self)
         return self.shapeObject
 class CylinderDescriptor(ShapeDescriptor):
     """
         Descriptor for a cylinder
         Orientation: Default cylinder is along Y
         Parameters:
             - Length [default = 40 A]
 …
         """
             Initialization
         """
+        """
         ShapeDescriptor.__init__(self)
         # Default parameters
         self.params["type"]   = "cylinder"
+        self.params["type"] = "cylinder"
         # Length of the cylinder
         self.params["length"] = 40.0
 …
         # Constrast parameter
         self.params["contrast"] = 1.0
     def create(self):
         """
 …
         ShapeDescriptor.create(self)
         return self.shapeObject
 class EllipsoidDescriptor(ShapeDescriptor):
     """
         Descriptor for an ellipsoid
         Parameters:
             - Radius_x along the x-axis [default = 30 A]
 …
         """
             Initialization
         """
+        """
         ShapeDescriptor.__init__(self)
         # Default parameters
         self.params["type"]   = "ellipsoid"
+        self.params["type"] = "ellipsoid"
         self.params["radius_x"] = 30.0
         self.params["radius_y"] = 20.0
         self.params["radius_z"] = 10.0
         self.params["contrast"] = 1.0
     def create(self):
         """
 …
         """
         self.shapeObject = geoshapespy.new_ellipsoid(\
             self.params["radius_x"], self.params["radius_y"],
+            self.params["radius_x"], self.params["radius_y"],
             self.params["radius_z"])
         ShapeDescriptor.create(self)
+        ShapeDescriptor.create(self)
         return self.shapeObject
 class HelixDescriptor(ShapeDescriptor):
     """
         Descriptor for an helix
         Parameters:
             -radius_helix: the radius of the helix [default = 10 A]
 …
         """
             Initialization
         """
+        """
         ShapeDescriptor.__init__(self)
         # Default parameters
         self.params["type"]   = "singlehelix"
+        self.params["type"] = "singlehelix"
         self.params["radius_helix"] = 10.0
         self.params["radius_tube"] = 3.0
 …
         """
         self.shapeObject = geoshapespy.new_singlehelix(\
             self.params["radius_helix"], self.params["radius_tube"],
+            self.params["radius_helix"], self.params["radius_tube"],
             self.params["pitch"], self.params["turns"])
         ShapeDescriptor.create(self)
+        ShapeDescriptor.create(self)
         return self.shapeObject
 class PDBDescriptor(ShapeDescriptor):
     """
         Descriptor for a PDB set of points
         Parameter:
             - file = name of the PDB file
 …
             Initialization
             @param filename: name of the PDB file to load
         """
+        """
         ShapeDescriptor.__init__(self)
         # Default parameters
         self.params["type"]   = "pdb"
+        self.params["type"] = "pdb"
         self.params["file"] = filename
         self.params['is_lores'] = False
 …
         """
         self.shapeObject = pointsmodelpy.new_pdbmodel()
         pointsmodelpy.pdbmodel_add(self.shapeObject, self.params['file'])
         #ShapeDescriptor.create(self)
+        pointsmodelpy.pdbmodel_add(self.shapeObject, self.params['file'])
+        #ShapeDescriptor.create(self)
         return self.shapeObject
 # Define a dictionary for the shape until we find
 # a better way to create them
 …
               'ellipsoid':EllipsoidDescriptor,
               'singlehelix':HelixDescriptor}
 class VolumeCanvas(BaseComponent):
     """
         Class representing an empty space volume to add
+        Class representing an empty space volume to add
         geometrical object to.
         For 1D I(q) simulation, getPr() is called internally for the
         first call to getIq().
     """
+    """
     def __init__(self):
         """
 …
         """
         BaseComponent.__init__(self)
         ## Maximum value of q reachable
         self.params['q_max'] = 0.1
 …
         self.params['scale'] = 1.0
         self.params['background'] = 0.0
         self.lores_model = pointsmodelpy.new_loresmodel(self.params['lores_density'])
         self.complex_model = pointsmodelpy.new_complexmodel()
         self.shapes = {}
         self.shapecount = 0
+        self.shapecount = 0
         self.points = None
         self.npts = 0
         self.hasPr = False
+        self.hasPr = False
     def _model_changed(self):
         """
             Reset internal data members to reflect the fact that the
+            Reset internal data members to reflect the fact that the
             real-space model has changed
         """
         self.hasPr  = False
+        self.hasPr = False
         self.points = None
     def addObject(self, shapeDesc, id = None):
+    def addObject(self, shapeDesc, id=None):
         """
             Adds a real-space object to the canvas.
             @param shapeDesc: object to add to the canvas [ShapeDescriptor]
             @param id: string handle for the object [string] [optional]
 …
         if id is None:
             id = shapeDesc.params["type"]+str(self.shapecount)
         # Self the order number
         shapeDesc.params['order'] = self.shapecount
 …
         return id
     def add(self, shape, id = None):
+    def add(self, shape, id=None):
         """
             The intend of this method is to eventually be able to use it
 …
             analytical solutions. For instance, if one adds a cylinder and
             it is the only shape on the canvas, the analytical solution
             could be called. If multiple shapes are involved, then
+            could be called. If multiple shapes are involved, then
             simulation has to be performed.
             This function is deprecated, use addObject().
             @param shape: name of the object to add to the canvas [string]
             @param id: string handle for the object [string] [optional]
 …
         if id is None:
             id = "shape"+str(self.shapecount)
         # shapeDesc = ShapeDescriptor(shape.lower())
         if shape.lower() in shape_dict:
 …
         else:
             raise ValueError("VolumeCanvas.add: Unknown shape %s" % shape)
         return self.addObject(shapeDesc, id)
 …
     def setParam(self, name, value):
         """
             Function to set the value of a parameter.
+    def setParam(self, name, value):
+        """
+            Function to set the value of a parameter.
             Both VolumeCanvas parameters and shape parameters
             are accessible.
+            are accessible.
             Note: if shape parameters are accessed directly
             from outside VolumeCanvas. The getPr method
             should be called before evaluating I(q).
             TODO: implemented a check method to protect
             against that.
             @param name: name of the parameter to change
             @param value: value to give the parameter
         """
         # Lowercase for case insensitivity
         name = name.lower()
         # Look for shape access
         toks = name.split('.')
         # If a shape identifier was given, look the shape up
         # in the dictionary
 …
             else:
                 raise ValueError("Could not find shape %s" % toks[0])
         else:
             # If we are not accessing the parameters of a
+            # If we are not accessing the parameters of a
             # shape, see if the parameter is part of this object
             BaseComponent.setParam(self, name, value)
             self._model_changed()
     def getParam(self, name):
+    def getParam(self, name):
         """
             @param name: name of the parameter to change
         """
         #TODO: clean this up
         # Lowercase for case insensitivity
         name = name.lower()
         # Look for sub-model access
         toks = name.split('.')
 …
         else:
             raise ValueError("VolumeCanvas.getParam: Could not find %s" % name)
     def getParamList(self, shapeid=None):
         """
                return a full list of all available parameters from
+               return a full list of all available parameters from
            self.params.keys(). If a key in self.params is a instance
            of ShapeDescriptor, extend the return list to:
+           of ShapeDescriptor, extend the return list to:
            [param1,param2,shapeid.param1,shapeid.param2.......]
 …
                 header = key2 + '.'
                 for key3 in value2.params:
                     fullname = header + key3
+                    fullname = header + key3
                     param_list.append(fullname)
         else:
             if not shapeid in self.shapes:
 …
     def getShapeList(self):
         """
             Return a list of the shapes
+            Return a list of the shapes
         """
         return self.shapes.keys()
 …
         # Create the object model
         shapeDesc.create()
         if shapeDesc.params['is_lores']:
             # Add the shape to the lores_model
+            pointsmodelpy.lores_add(self.lores_model,
+                shapeDesc.shapeObject, shapeDesc.params['contrast'])
+            pointsmodelpy.lores_add(self.lores_model,
+                                    shapeDesc.shapeObject,
+                                    shapeDesc.params['contrast'])
     def _createVolumeFromList(self):
 …
             Whenever we change a parameter of a shape, we have to re-create
             the whole thing.
             Items with higher 'order' number take precedence for regions
             of space that are shared with other objects. Points in the
+            of space that are shared with other objects. Points in the
             overlapping region belonging to objects with lower 'order'
             will be ignored.
             Items are added in decreasing 'order' number.
             The item with the highest 'order' will be added *first*.
             [That conventions is prescribed by the realSpaceModeling module]
         """
         # Create empty model
         self.lores_model = \
 …
         # Create empty complex model
         self.complex_model = pointsmodelpy.new_complexmodel()
         # Order the object first
         obj_list = []
         for shape in self.shapes:
             order = self.shapes[shape].params['order']
             # find where to place it in the list
             stored = False
             for i in range(len(obj_list)):
                 if obj_list[i][0] > order:
 …
                     stored = True
                     break
             if not stored:
                 obj_list.append([order, shape])
         # Add each shape
         len_list = len(obj_list)
 …
             self._addSingleShape(shapedesc)
         return 0
+        return 0
     def getPr(self):
         """
 …
             This method should always be called after the shapes
             on the VolumeCanvas have changed.
             @return: calculation output flag
+            @return: calculation output flag
         """
         # To find a complete example of the correct call order:
         # In LORES2, in actionclass.py, method CalculateAction._get_iq()
         # If there are not shapes, do nothing
         if len(self.shapes) == 0:
             self._model_changed()
             return 0
         # generate space filling points from shape list
         self._createVolumeFromList()
 …
         self.points = pointsmodelpy.new_point3dvec()
         pointsmodelpy.complexmodel_add(self.complex_model,
                                         self.lores_model, "LORES")
+        pointsmodelpy.complexmodel_add(self.complex_model,
+                                       self.lores_model, "LORES")
         for shape in self.shapes:
             if self.shapes[shape].params['is_lores'] == False:
                 pointsmodelpy.complexmodel_add(self.complex_model,
+            if not self.shapes[shape].params['is_lores']:
+                pointsmodelpy.complexmodel_add(self.complex_model,
                     self.shapes[shape].shapeObject, "PDB")
         #pointsmodelpy.get_lorespoints(self.lores_model, self.points)
         self.npts = pointsmodelpy.get_complexpoints(self.complex_model, self.points)
         # expecting the rmax is a positive float or 0. The maximum distance.
         #rmax = pointsmodelpy.get_lores_pr(self.lores_model, self.points)
         rmax = pointsmodelpy.get_complex_pr(self.complex_model, self.points)
         self.hasPr = True
+        #rmax = pointsmodelpy.get_lores_pr(self.lores_model, self.points)
+        rmax = pointsmodelpy.get_complex_pr(self.complex_model, self.points)
+        self.hasPr = True
         return rmax
     def run(self, q = 0):
+    def run(self, q=0):
         """
             Returns the value of I(q) for a given q-value
 …
         else:
             raise ValueError("run(q): bad type for q")
     def runXY(self, q = 0):
+    def runXY(self, q=0):
         """
             Standard run command for the canvas.
             Redirects to the correct method
+            Redirects to the correct method
             according to the input type.
             @param q: q-value [float] or [list] [A-1]
 …
         else:
             raise ValueError("runXY(q): bad type for q")
     def _create_modelObject(self):
         """
             Create the simulation model obejct from the list
             of shapes.
             This method needs to be called each time a parameter
             changes because of the way the underlying library
             was (badly) written. It is impossible to change a
             parameter, or remove a shape without having to
+            was (badly) written. It is impossible to change a
+            parameter, or remove a shape without having to
             refill the space points.
             TODO: improve that.
         """
         # To find a complete example of the correct call order:
         # In LORES2, in actionclass.py, method CalculateAction._get_iq()
         # If there are not shapes, do nothing
         if len(self.shapes) == 0:
             self._model_changed()
             return 0
         # generate space filling points from shape list
         self._createVolumeFromList()
 …
         self.points = pointsmodelpy.new_point3dvec()
         pointsmodelpy.complexmodel_add(self.complex_model,
                                         self.lores_model, "LORES")
+        pointsmodelpy.complexmodel_add(self.complex_model,
+                                       self.lores_model, "LORES")
         for shape in self.shapes:
             if self.shapes[shape].params['is_lores'] == False:
                 pointsmodelpy.complexmodel_add(self.complex_model,
+            if not self.shapes[shape].params['is_lores']:
+                pointsmodelpy.complexmodel_add(self.complex_model,
                     self.shapes[shape].shapeObject, "PDB")
         #pointsmodelpy.get_lorespoints(self.lores_model, self.points)
         self.npts = pointsmodelpy.get_complexpoints(self.complex_model, self.points)
     def getIq2D(self, qx, qy):
         """
 …
             @return: I(q) [cm-1]
         """
         # If this is the first simulation call, we need to generate the
         # space points
         if self.points is None:
             self._create_modelObject()
             # Protect against empty model
             if self.points is None:
                 return 0
         # Evalute I(q)
         norm =  1.0e8/self.params['lores_density']*self.params['scale']
+        # Evalute I(q)
+        norm = 1.0e8/self.params['lores_density']*self.params['scale']
         return norm*pointsmodelpy.get_complex_iq_2D(self.complex_model, self.points, qx, qy)\
             + self.params['background']
     def write_pr(self, filename):
         """
             Write P(r) to an output file
             @param filename: file name for P(r) output
         """
         if self.hasPr == False:
+        """
+        if not self.hasPr:
             self.getPr()
         pointsmodelpy.outputPR(self.complex_model, filename)
     def getPrData(self):
         """
             Write P(r) to an output file
             @param filename: file name for P(r) output
         """
         if self.hasPr == False:
+        """
+        if not self.hasPr:
             self.getPr()
         return pointsmodelpy.get_pr(self.complex_model)
     def getIq(self, q):
         """
             Returns the value of I(q) for a given q-value
             This method should remain internal to the class
             and the run() method should be used instead.
             @param q: q-value [float]
             @return: I(q) [float]
         """
         if self.hasPr == False:
+        if not self.hasPr:
             self.getPr()
         # By dividing by the density instead of the actuall V/N,
         # we have an uncertainty of +-1 on N because the number
+        # By dividing by the density instead of the actuall V/N,
+        # we have an uncertainty of +-1 on N because the number
         # of points chosen for the simulation is int(density*volume).
         # Propagation of error gives:
 …
         # where N is stored in self.npts
         norm =  1.0e8/self.params['lores_density']*self.params['scale']
+        norm = 1.0e8/self.params['lores_density']*self.params['scale']
         #return norm*pointsmodelpy.get_lores_i(self.lores_model, q)
         return norm*pointsmodelpy.get_complex_i(self.complex_model, q)\
             + self.params['background']
     def getError(self, q):
         """
 …
             @return: I(q) [float]
         """
         if self.hasPr == False:
+        if not self.hasPr:
             self.getPr()
         # By dividing by the density instead of the actual V/N,
         # we have an uncertainty of +-1 on N because the number
+        # By dividing by the density instead of the actual V/N,
+        # we have an uncertainty of +-1 on N because the number
         # of points chosen for the simulation is int(density*volume).
         # Propagation of error gives:
 …
         # where N is stored in self.npts
         norm =  1.0e8/self.params['lores_density']*self.params['scale']
+        norm = 1.0e8/self.params['lores_density']*self.params['scale']
         #return norm*pointsmodelpy.get_lores_i(self.lores_model, q)
         return norm*pointsmodelpy.get_complex_i_error(self.complex_model, q)\
             + self.params['background']
     def getIqError(self, q):
         """
             Return the simulated value along with its estimated
             error for a given q-value
             Propagation of errors is used to evaluate the
             uncertainty.
             @param q: q-value [float]
             @return: mean, error [float, float]
 …
             Return the simulated value along with its estimated
             error for a given q-value
             Propagation of errors is used to evaluate the
             uncertainty.
             @param qx: qx-value [float]
             @param qy: qy-value [float]
 …
         """
         self._create_modelObject()
         norm =  1.0e8/self.params['lores_density']*self.params['scale']
+        norm = 1.0e8/self.params['lores_density']*self.params['scale']
         val = norm*pointsmodelpy.get_complex_iq_2D(self.complex_model, self.points, qx, qy)\
             + self.params['background']
         # Simulation error (statistical)
         norm =  1.0e8/self.params['lores_density']*self.params['scale'] \
                 * math.pow(self.npts/self.params['lores_density'], 1.0/3.0)/self.npts
+        norm = 1.0e8/self.params['lores_density']*self.params['scale'] \
+               * math.pow(self.npts/self.params['lores_density'], 1.0/3.0)/self.npts
         err = norm*pointsmodelpy.get_complex_iq_2D_err(self.complex_model, self.points, qx, qy)
         # Error on V/N
         simerr = 2*val/self.npts
         # The error used for the position is over-simplified.
         # The actual error was empirically found to be about
         # an order of magnitude larger.
         return val, 10.0*err+simerr

src/sas/sasgui/guiframe/CategoryInstaller.py

-                      r235f514
+                      r65f3930
 logger = logging.getLogger(__name__)
 class CategoryInstaller:
+class CategoryInstaller(object):
     """
     Class for making sure all category stuff is installed
 …
         returns the dir where installed_models.txt should be
         """
+        import sas.sascalc.dataloader.readers
+        return sas.sascalc.dataloader.readers.get_data_path()
+    @staticmethod
+    def _get_models_py_dir():
+        """
+        returns the dir where models.py should be
+        """
+        import sas.sasgui.perspectives.fitting.models
+        return sas.sasgui.perspectives.fitting.models.get_model_python_path()
+        from sas.sascalc.dataloader.readers import get_data_path
+        return get_data_path()
     @staticmethod
 …
         by_model_dict = defaultdict(list)
         model_enabled_dict = defaultdict(bool)
         for category in master_category_dict:
             for (model, enabled) in master_category_dict[category]:
 …
     def _regenerate_master_dict(by_model_dict, model_enabled_dict):
         """
         regenerates master_category_dict from by_model_dict
+        regenerates master_category_dict from by_model_dict
         and model_enabled_dict
         returns the master category dictionary
 …
                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()
 …
                 model_name, enabled = master_category_dict[cat][ind]
                 if model_name not in _model_list:
                     del_name = True
+                    del_name = True
                     try:
                         by_model_dict.pop(model_name)
                         model_enabled_dict.pop(model_name)
                     except:
+                    except Exception:
                         logger.error("CategoryInstaller: %s", sys.exc_value)
                 else:
 …
         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/perspectives/calculator/model_editor.py

                       r23359ccb
 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:
 …
     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
 …
             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:
 …
             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:
 …
                     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)
 …
             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
 …
         :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):
 …
         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"
 …
 ## 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
 …
 """
 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

                       r33dc18f
 import sys
 import os
-import wx
-import numpy as np
 import time
 import copy
 …
 import logging
 import traceback
 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
 …
 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__)
 …
         self.disp_cb_dict = {}
         # self.state = PageState(parent=parent)
+        # self.state = PageState()
         # dictionary containing list of models
         self.model_list_box = {}
 …
         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
 …
         """
         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}")
 …
         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}")
 …
         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):
 …
         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"])
 …
         # 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):
 …
             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 = \
 …
         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)
 …
                                     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)
 …
             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 = \
 …
                         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)
 …
             # to support older version
             category_pos = int(state.categorycombobox)
         except:
+        except Exception:
             category_pos = 0
             for ind_cat in range(self.categorybox.GetCount()):
 …
             # to support older version
             formfactor_pos = int(state.formfactorcombobox)
         except:
+        except Exception:
             formfactor_pos = 0
             for ind_form in range(self.formfactorbox.GetCount()):
 …
             # to support older version
             structfactor_pos = int(state.structurecombobox)
         except:
+        except Exception:
             structfactor_pos = 0
             for ind_struct in range(self.structurebox.GetCount()):
 …
         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
 …
             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
 …
             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)
 …
         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]()
 …
                         try:
                             self.npts_x = float(self.Npts_total.GetValue())
                         except:
+                        except Exception:
                             flag = False
                             return flag
 …
             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] ==
 …
         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))
 …
                     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)
 …
         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
 …
             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()
 …
                     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]
 …
                     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]
 …
         if struct_factor is not None:
-            from sasmodels.sasview_model import MultiplicationModel
             self.model = MultiplicationModel(form_factor(self.multi_factor),
                                              struct_factor())
 …
             # 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) & \
 …
         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:
 …
         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.
 …
                 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))
 …
         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
 …
             # 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
 …
         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
 …
                 # Only print errors for fitted parameters
                 content += param[4].GetValue()
                 content += tab
+                content += tab
         return content
 …
             # 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)
 …
         for param in all_params:
             content += 'l|l|'
         content += '}\hline'
+        content += r'}\hline'
         content += crlf
 …
         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
 …
             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
 …
                                 if name.endswith('.npts'):
                                     pd = int(pd)
                             except:
+                            except Exception:
                                 # continue
                                 if not pd and pd != '':
 …
                 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] = \
 …
         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]
 …
         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)
 …
         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

-                      r7432acb
+                      r50fcb09
 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()
 …
 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):
 …
 #         """
 #         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)
 …
 #         self.sizer_set_masking = wx.BoxSizer(wx.HORIZONTAL)
 #         sizer_chi2 = wx.BoxSizer(wx.VERTICAL)
+#
+#
 #         sizer_fit = wx.GridSizer(2, 4, 2, 6)
 #         #Fit button
 …
 #         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
 …
 #          #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)
 …
 #         self.state.structurecombobox = self.structurebox.GetCurrentSelection()
 #         self.state.formfactorcombobox = self.formfactorbox.GetCurrentSelection()
+#
+#
 #         if self.model is not None:
 #             self._set_copy_flag(True)
 …
 #                 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():
 …
 #             self._draw_model()
 #         self.SetupScrolling()
 #         self.Show(True)
+#
+#         self.Show(True)
+#
 #     def _update_paramv_on_fit(self):
 #         """
 …
 #         self.fitrange = True
 #         is_modified = False
+#
+#
 #         if self.model is not None:
 #             ##Check the values
 …
 #             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)
 …
 #                     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()
 …
 #             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):
 #         """
 …
 #     def set_data(self, data):
 #         """
 #         reset the current data
+#         reset the current data
 #         """
 #         #id = None
 …
 #             self._set_save_flag(False)
 #             self._set_preview_flag(True)
+#
+#
 #             self.formfactorbox.Enable()
 #             self.structurebox.Enable()
 …
 #             #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
 …
 #         self.state.qmin = self.qmin_x
 #         self.state.qmax = self.qmax_x
+#
+#
 #         #update model plot with new data information
 #         if flag:
 …
 #                 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

-                      r959eb01
+                      rba8d326
                  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
 …
             # 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.
 …
             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/fitpage.py

                       r79e6a33
 from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS
+from sas.sascalc.fit.qsmearing import smear_selection
 from sas.sasgui.guiframe.events import StatusEvent, NewPlotEvent, \
     PlotQrangeEvent
 …
 from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent as \
     PageInfoEvent
-from sas.sascalc.data_util.qsmearing import smear_selection
 from .basepage import ModelTextCtrl
 …
             self.model.name = "M" + str(self.index_model)
     def _on_select_model(self, event=None):
+    def _on_select_model(self, event=None, keep_pars=False):
         """
         call back for model selection
         """
         self.Show(False)
-        copy_flag = False
-        is_poly_enabled = None
         if event is not None:
+            if (event.GetEventObject() == self.formfactorbox
+                    and self.structurebox.GetLabel() != 'None')\
+                    or event.GetEventObject() == self.structurebox\
+                    or event.GetEventObject() == self.multifactorbox:
+                copy_flag = self.get_copy_params()
+                is_poly_enabled = self.enable_disp.GetValue()
+            control = event.GetEventObject()
+            if ((control == self.formfactorbox
+                 and self.structurebox.GetLabel() != 'None')
+                    or control == self.structurebox
+                    or control == self.multifactorbox):
+                keep_pars = True
+        if keep_pars:
+            saved_pars = self.get_copy_params()
+            is_poly_enabled = self.enable_disp.GetValue()
+        else:
+            saved_pars = None
+            is_poly_enabled = None
         try:
             self._on_select_model_helper()
 …
         try:
             self.set_dispers_sizer()
         except:
+        except Exception:
             pass
         self.state.enable_disp = self.enable_disp.GetValue()
 …
             self.state.model.name = self.model.name
+        # when select a model only from guictr/button
+        if is_poly_enabled is not None:
+            self.enable_disp.SetValue(is_poly_enabled)
+            self.disable_disp.SetValue(not is_poly_enabled)
+            self._set_dipers_Param(event=None)
+            self.state.enable_disp = self.enable_disp.GetValue()
+            self.state.disable_disp = self.disable_disp.GetValue()
+        # Keep the previous param values
+        if saved_pars:
+            self.get_paste_params(saved_pars)
         if event is not None:
+            # update list of plugins if new plugin is available
+            # mod_cat = self.categorybox.GetStringSelection()
+            # if mod_cat == CUSTOM_MODEL:
+            #     temp = self.parent.update_model_list()
+            #     for v in self.parent.model_dictionary.values():
+            #         if v.id == self.model.id:
+            #             self.model = v()
+            #             break
+            #     if temp:
+            #         self.model_list_box = temp
+            #         current_val = self.formfactorbox.GetLabel()
+            #         pos = self.formfactorbox.GetSelection()
+            #         self._show_combox_helper()
+            #         self.formfactorbox.SetStringSelection(current_val)
+            #         self.formfactorbox.SetValue(current_val)
             # post state to fit panel
             new_event = PageInfoEvent(page=self)
             wx.PostEvent(self.parent, new_event)
-            # update list of plugins if new plugin is available
-            mod_cat = self.categorybox.GetStringSelection()
-            if mod_cat == CUSTOM_MODEL:
-                temp_id = self.model.id
-                temp = self.parent.update_model_list()
-                for v in self.parent.model_dictionary.values():
-                    if v.id == temp_id:
-                        self.model = v()
-                        break
-                if temp:
-                    self.model_list_box = temp
-                    current_val = self.formfactorbox.GetLabel()
-                    pos = self.formfactorbox.GetSelection()
-                    self._show_combox_helper()
-                    self.formfactorbox.SetSelection(pos)
-                    self.formfactorbox.SetValue(current_val)
-            # when select a model only from guictr/button
-            if is_poly_enabled is not None:
-                self.enable_disp.SetValue(is_poly_enabled)
-                self.disable_disp.SetValue(not is_poly_enabled)
-                self._set_dipers_Param(event=None)
-                self.state.enable_disp = self.enable_disp.GetValue()
-                self.state.disable_disp = self.disable_disp.GetValue()
-            # Keep the previous param values
-            if copy_flag:
-                self.get_paste_params(copy_flag)
             wx.CallAfter(self._onDraw, None)
 …
                 and not self.temp_multi_functional:
             return None
+        print("_set_fun_box_list", self.model.name)
         # Get the func name list
         list = self.model.fun_list
 …
         ind = 0
         while(ind < len(list)):
             for key, val in list.iteritems():
                 if (val == ind):
+            for key, val in list.items():
+                if val == ind:
                     fun_box.Append(key, val)
                     break

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

                       rc9ecd1b
 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
 …
         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
 …
         """
         temp = self.menu_mng.update()
         if len(temp):
+        if temp:
             self.model_list_box = temp
         return temp
 …
         """
         """
+        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):
 …
         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
         """
 …
         Add the simultaneous fit page
         """
-        from simfitpage import SimultaneousFitPage
         page_finder = self._manager.get_page_finder()
         if caption == "Const & Simul Fit":
 …
         """
         if self.batch_on:
-            from batchfitpage import BatchFitPage
             panel = BatchFitPage(parent=self)
             self.batch_page_index += 1
 …
         else:
             # Increment index of fit page
-            from fitpage import FitPage
             panel = FitPage(parent=self)
             self.fit_page_index += 1
 …
         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)
 …
         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

-                      r959eb01
+                      r251ef684
 ################################################################################
 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):
         """
 …
             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):
 …
         :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):
 …
         :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: 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):
 …
         :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):
 …
         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
+        """
+    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):
 …
         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):
 …
         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
         """
+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
 …
         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):
 …
         """
         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):
 …
         return smear object
         """
         if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_smearer()
 …
         """
         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):
 …
         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
 …
         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):
 …
         :return: saved model
         """
         if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_model()
 …
         :param data: data selected
         """
         if fid in self.iterkeys():
+        if fid in self:
             self[fid].set_residuals(residuals)
 …
         :return: residuals
         """
         if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_residuals()
 …
         :param data: data selected
         """
         if fid in self.iterkeys():
+        if fid in self:
             self[fid].set_theory_data(data)
 …
         :return: list of data dList
         """
         if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_theory_data()
 …
         :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)
 …
             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)
 …
         :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()
 …
         """
         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):
 …
         return list of couple of parameter name and value
         """
         if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_model_param()
 …
         """
         self.scheduled = schedule
         for value in self.itervalues():
+        for value in self.values():
             value.schedule_tofit(schedule)
 …
         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):
 …
         :return: fitting range
         """
         if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_range()
 …
         """
         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):
 …
         return fit weight
         """
         if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_weight()
 …
         """
         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):
 …
         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)
 …
         get result
         """
         if fid in self.iterkeys():
+        if fid in self:
             return self[fid].get_result()
 …
         """
         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

                       r2504b5a
 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
 …
 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 .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__)
 …
     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):
 …
         Get the python editor panel
         """
+        from sas.sasgui.perspectives.calculator.pyconsole import PyConsole
         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,
 …
                         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')
 …
         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',
 …
             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)
 …
         #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)
 …
         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:
 …
         : 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 = []
 …
                 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
 …
                 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)
 …
         """
         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
 …
             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,
 …
             ## 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):
 …
         :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)
 …
                     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
 …
                             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)
 …
             ## 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
 …
                 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"))
 …
                     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:
 …
                     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)
 …
         if "Data" not in batch_outputs.keys():
             batch_outputs["Data"] = []
-        from sas.sasgui.guiframe.data_processor import BatchCell
         cell = BatchCell()
         cell.label = data.name
 …
                     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)
 …
                                                   fid=data.id)
         self.parent.update_theory(data_id=data.id, theory=new_plot,
                                    state=state)
+                                  state=state)
         return new_plot
 …
             @param unsmeared_error: data error, rescaled to unsmeared model
         """
+<<<<<<< HEAD
+=======
+>>>>>>> master
         number_finite = np.count_nonzero(np.isfinite(y))
         np.nan_to_num(y)
 …
         # 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",
 …
             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",
 …
             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'))
 …
         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,
 …
             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!"
 …
     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
 …
                                                   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!"
 …
                       weight=None,
                       toggle_mode_on=False,
                        update_chisqr=True, source='model'):
+                      update_chisqr=True, source='model'):
         """
         draw model in 2D
 …
             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():
 …
     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
 …
             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

                       r0f9ea1c
 """
     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
 …
                  worktime=0.04,
                  exception_handler=None,
                  ):
+                ):
         CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime,
                             exception_handler=exception_handler)
 …
         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:
 …
         # 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:
 …
         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)
 …
                  worktime=0.01,
                  exception_handler=None,
                  ):
+                ):
         """
         """
 …
                                                         * 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])
 …
     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
 …
             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()
 …
         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

-                      r7432acb
+                      r78312f7
         # 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()
 …
             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
 …
                     #Windows
                     os.startfile(str(fName))
                 except:
+                except Exception:
                     try:
                         #Mac
                         os.system("open %s" % fName)
                     except:
+                    except Exception:
                         #DO not open
                         pass

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

-                      ra9f9ca4
+                      r00f7ff1
     Simultaneous or Batch fit page
 """
 # Note that this is used for both Simultaneous/Constrained fit AND for
+# Note that this is used for both Simultaneous/Constrained fit AND for
 # combined batch fit.  This is done through setting of the batch_on parameter.
 # There are the a half dozen or so places where an if statement is used as in
+# There are the a half dozen or so places where an if statement is used as in
 # if not batch_on:
 #     xxxx
 …
 # This is just wrong but dont have time to fix this go. Proper approach would be
 # to strip all parts of the code that depend on batch_on and create the top
 # level class from which a contrained/simultaneous fit page and a combined
+# level class from which a contrained/simultaneous fit page and a combined
 # batch page inherit.
+#
 …
 from wx.lib.scrolledpanel import ScrolledPanel
+from sas.sascalc.fit.pagestate import SimFitPageState
 from sas.sasgui.guiframe.events import StatusEvent, PanelOnFocusEvent
 from sas.sasgui.guiframe.panel_base import PanelBase
 …
     return fittable_param
 class SimultaneousFitPage(ScrolledPanel, PanelBase):
 …
         return self.state
+    def load_from_save_state(self, sim_state):
+        """
+        Load in a simultaneous/constrained fit from a save state
+        :param fit: Fitpanel object
+        :return: None
+        """
+        model_map = {}
+        # Process each model and associate old M# with new M#
+        i = 0
+        for model in self.model_list:
+            model_id = self._format_id(model[1].keys()[0])
+            for saved_model in sim_state.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:
+                    model_map[saved_model.pop('fit_page_source')] = \
+                        model[3].name
+                    check = bool(saved_model.pop('checked'))
+                    self.model_list[i][0].SetValue(check)
+                    break
+            i += 1
+        self.check_model_name(None)
+        if len(sim_state.constraints_list) > 0:
+            self.hide_constraint.SetValue(False)
+            self.show_constraint.SetValue(True)
+            self._display_constraint(None)
+        for index, item in enumerate(sim_state.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 model_map.iteritems():
+                    model_cbox.replace(key, value)
+                    constraint_value.replace(key, value)
+                self.constraints_list[index][0].SetValue(model_cbox)
+                self._on_select_model(None)
+                self.constraints_list[index][1].SetValue(param)
+                self.constraints_list[index][2].SetLabel(equality)
+                self.constraints_list[index][3].SetValue(constraint_value)
+                self._on_add_constraint(None)
+                self._manager.sim_page = self
+    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
     def draw_page(self):
         """
         Construct the Simultaneous/Constrained fit page. fills the first
         region (sizer1) with the list of available fit page pairs of data
+        region (sizer1) with the list of available fit page pairs of data
         and models.  Then fills sizer2 with the checkbox for adding
         constraints, and finally fills sizer3 with the fit button and
 …
         cbox.Append(name, value)
     cbox.SetStringSelection(selected)
-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
-        """
-        model_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:
-                    model_map[saved_model.pop('fit_page_source')] = \
-                        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 model_map.iteritems():
-                    model_cbox.replace(key, 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

SasView

Changes in / [d76c43a:69363c7] in sasview

Legend:

sasview/sasview.py

src/sas/sascalc/fit/AbstractFitEngine.py

src/sas/sascalc/fit/BumpsFitting.py

src/sas/sascalc/pr/fit/AbstractFitEngine.py

src/sas/sascalc/realspace/VolumeCanvas.py

src/sas/sasgui/guiframe/CategoryInstaller.py

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

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

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

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

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

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

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

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

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

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

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

Download in other formats: