Changeset 706bb4e for src/sas/sasgui – SasView

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

-                      r235f514
+                      r2d9526d
 import wx
 import sys
+from copy import deepcopy
 from sas.sasgui.guiframe.events import EVT_NEW_PLOT
 from sas.sasgui.guiframe.events import EVT_PLOT_QRANGE
 …
                 action_check = True
             else:
+                if action_string == 'update':
+                    # Update all existing plots of data with this ID
+                    for data in event.plots:
+                        for panel in self.plot_panels.values():
+                            if data.id in panel.plots.keys():
+                                plot_exists = True
+                                # Pass each panel it's own copy of the data
+                                # that's being updated, otherwise things like
+                                # colour and line thickness are unintentionally
+                                # synced across panels
+                                self.update_panel(deepcopy(data), panel)
+                    return
                 group_id = event.group_id
                 if group_id in self.plot_panels.keys():
+                if group_id in self.plot_panels:
                     #remove data from panel
                     if action_string == 'remove':

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

-                      r07ec714
+                      r23359ccb
         self.model2_string = "cylinder"
         self.name = 'Sum' + M_NAME
-        self.factor = 'scale_factor'
         self._notes = ''
         self._operator = '+'
 …
         self.model2_name = str(self.model2.GetValue())
         self.good_name = True
         self.fill_oprator_combox()
+        self.fill_operator_combox()
     def _layout_name(self):
 …
         a sum or multiply model then create the appropriate string
         """
         name = ''
         if operator == '*':
             name = 'Multi'
+            factor = 'BackGround'
+            f_oper = '+'
+            factor = 'background'
         else:
             name = 'Sum'
             factor = 'scale_factor'
+            f_oper = '*'
+        self.factor = factor
         self._operator = operator
         self.explanation = "  Plugin Model = %s %s (model1 %s model2)\n" % \
                            (self.factor, f_oper, self._operator)
+        self.explanation = ("  Plugin_model = scale_factor * (model_1 {} "
+            "model_2) + background").format(operator)
         self.explanationctr.SetLabel(self.explanation)
         self.name = name + M_NAME
     def fill_oprator_combox(self):
+    def fill_operator_combox(self):
         """
         fill the current combobox with the operator
 …
         return [self.model1_name, self.model2_name]
     def write_string(self, fname, name1, name2):
+    def write_string(self, fname, model1_name, model2_name):
         """
         Write and Save file
 …
         self.fname = fname
         description = self.desc_tcl.GetValue().lstrip().rstrip()
+        if description == '':
+            description = name1 + self._operator + name2
+        text = self._operator_choice.GetValue()
+        if text.count('+') > 0:
+            factor = 'scale_factor'
+            f_oper = '*'
+            default_val = '1.0'
+        else:
+            factor = 'BackGround'
+            f_oper = '+'
+            default_val = '0.0'
+        path = self.fname
+        try:
+            out_f = open(path, 'w')
+        except:
+            raise
+        lines = SUM_TEMPLATE.split('\n')
+        for line in lines:
+            try:
+                if line.count("scale_factor"):
+                    line = line.replace('scale_factor', factor)
+                    #print "scale_factor", line
+                if line.count("= %s"):
+                    out_f.write(line % (default_val) + "\n")
+                elif line.count("import Model as P1"):
+                    if self.is_p1_custom:
+                        line = line.replace('#', '')
+                        out_f.write(line % name1 + "\n")
+                    else:
+                        out_f.write(line + "\n")
+                elif line.count("import %s as P1"):
+                    if not self.is_p1_custom:
+                        line = line.replace('#', '')
+                        out_f.write(line % (name1) + "\n")
+                    else:
+                        out_f.write(line + "\n")
+                elif line.count("import Model as P2"):
+                    if self.is_p2_custom:
+                        line = line.replace('#', '')
+                        out_f.write(line % name2 + "\n")
+                    else:
+                        out_f.write(line + "\n")
+                elif line.count("import %s as P2"):
+                    if not self.is_p2_custom:
+                        line = line.replace('#', '')
+                        out_f.write(line % (name2) + "\n")
+                    else:
+                        out_f.write(line + "\n")
+                elif line.count("P1 = find_model"):
+                    out_f.write(line % (name1) + "\n")
+                elif line.count("P2 = find_model"):
+                    out_f.write(line % (name2) + "\n")
+                elif line.count("self.description = '%s'"):
+                    out_f.write(line % description + "\n")
+                #elif line.count("run") and line.count("%s"):
+                #    out_f.write(line % self._operator + "\n")
+                #elif line.count("evalDistribution") and line.count("%s"):
+                #    out_f.write(line % self._operator + "\n")
+                elif line.count("return") and line.count("%s") == 2:
+                    #print "line return", line
+                    out_f.write(line % (f_oper, self._operator) + "\n")
+                elif line.count("out2")and line.count("%s"):
+                    out_f.write(line % self._operator + "\n")
+                else:
+                    out_f.write(line + "\n")
+            except:
+                raise
+        out_f.close()
+        #else:
+        #    msg = "Name exists already."
+        desc_line = ''
+        if description.strip() != '':
+            # Sasmodels generates a description for us. If the user provides
+            # their own description, add a line to overwrite the sasmodels one
+            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,
+            model2=model2_name, operator=self._operator, desc_line=desc_line)
+        with open(self.fname, 'w') as out_f:
+            out_f.write(output)
     def compile_file(self, path):
 …
 """
 SUM_TEMPLATE = """
+# A sample of an experimental model function for Sum/Multiply(Pmodel1,Pmodel2)
+import os
+import sys
+import copy
+import collections
+import numpy
+from sas.sascalc.fit.pluginmodel import Model1DPlugin
+from sasmodels.sasview_model import find_model
+class Model(Model1DPlugin):
+    name = os.path.splitext(os.path.basename(__file__))[0]
+    is_multiplicity_model = False
+    def __init__(self, multiplicity=1):
+        Model1DPlugin.__init__(self, name='')
+        P1 = find_model('%s')
+        P2 = find_model('%s')
+        p_model1 = P1()
+        p_model2 = P2()
+        ## Setting  model name model description
+        self.description = '%s'
+        if self.name.rstrip().lstrip() == '':
+            self.name = self._get_name(p_model1.name, p_model2.name)
+        if self.description.rstrip().lstrip() == '':
+            self.description = p_model1.name
+            self.description += p_model2.name
+            self.fill_description(p_model1, p_model2)
+        ## Define parameters
+        self.params = collections.OrderedDict()
+        ## Parameter details [units, min, max]
+        self.details = {}
+        ## Magnetic Panrameters
+        self.magnetic_params = []
+        # non-fittable parameters
+        self.non_fittable = p_model1.non_fittable
+        self.non_fittable += p_model2.non_fittable
+        ##models
+        self.p_model1= p_model1
+        self.p_model2= p_model2
+        ## dispersion
+        self._set_dispersion()
+        ## Define parameters
+        self._set_params()
+        ## New parameter:scaling_factor
+        self.params['scale_factor'] = %s
+        ## Parameter details [units, min, max]
+        self._set_details()
+        self.details['scale_factor'] = ['', 0.0, numpy.inf]
+        #list of parameter that can be fitted
+        self._set_fixed_params()
+        ## parameters with orientation
+        self.orientation_params = []
+        for item in self.p_model1.orientation_params:
+            new_item = "p1_" + item
+            if not new_item in self.orientation_params:
+                self.orientation_params.append(new_item)
+        for item in self.p_model2.orientation_params:
+            new_item = "p2_" + item
+            if not new_item in self.orientation_params:
+                self.orientation_params.append(new_item)
+        ## magnetic params
+        self.magnetic_params = []
+        for item in self.p_model1.magnetic_params:
+            new_item = "p1_" + item
+            if not new_item in self.magnetic_params:
+                self.magnetic_params.append(new_item)
+        for item in self.p_model2.magnetic_params:
+            new_item = "p2_" + item
+            if not new_item in self.magnetic_params:
+                self.magnetic_params.append(new_item)
+        # get multiplicity if model provide it, else 1.
+        try:
+            multiplicity1 = p_model1.multiplicity
+            try:
+                multiplicity2 = p_model2.multiplicity
+            except:
+                multiplicity2 = 1
+        except:
+            multiplicity1 = 1
+            multiplicity2 = 1
+        ## functional multiplicity of the model
+        self.multiplicity1 = multiplicity1
+        self.multiplicity2 = multiplicity2
+        self.multiplicity_info = []
+    def _clone(self, obj):
+        import copy
+        obj.params     = copy.deepcopy(self.params)
+        obj.description     = copy.deepcopy(self.description)
+        obj.details    = copy.deepcopy(self.details)
+        obj.dispersion = copy.deepcopy(self.dispersion)
+        obj.p_model1  = self.p_model1.clone()
+        obj.p_model2  = self.p_model2.clone()
+        #obj = copy.deepcopy(self)
+        return obj
+    def _get_name(self, name1, name2):
+        p1_name = self._get_upper_name(name1)
+        if not p1_name:
+            p1_name = name1
+        name = p1_name
+        name += "_and_"
+        p2_name = self._get_upper_name(name2)
+        if not p2_name:
+            p2_name = name2
+        name += p2_name
+        return name
+    def _get_upper_name(self, name=None):
+        if name is None:
+            return ""
+        upper_name = ""
+        str_name = str(name)
+        for index in range(len(str_name)):
+            if str_name[index].isupper():
+                upper_name += str_name[index]
+        return upper_name
+    def _set_dispersion(self):
+        self.dispersion = collections.OrderedDict()
+        ##set dispersion only from p_model
+        for name , value in self.p_model1.dispersion.iteritems():
+            #if name.lower() not in self.p_model1.orientation_params:
+            new_name = "p1_" + name
+            self.dispersion[new_name]= value
+        for name , value in self.p_model2.dispersion.iteritems():
+            #if name.lower() not in self.p_model2.orientation_params:
+            new_name = "p2_" + name
+            self.dispersion[new_name]= value
+    def function(self, x=0.0):
+        return 0
+    def getProfile(self):
+        try:
+            x,y = self.p_model1.getProfile()
+        except:
+            x = None
+            y = None
+        return x, y
+    def _set_params(self):
+        for name , value in self.p_model1.params.iteritems():
+            # No 2D-supported
+            #if name not in self.p_model1.orientation_params:
+            new_name = "p1_" + name
+            self.params[new_name]= value
+        for name , value in self.p_model2.params.iteritems():
+            # No 2D-supported
+            #if name not in self.p_model2.orientation_params:
+            new_name = "p2_" + name
+            self.params[new_name]= value
+        # Set "scale" as initializing
+        self._set_scale_factor()
+    def _set_details(self):
+        for name ,detail in self.p_model1.details.iteritems():
+            new_name = "p1_" + name
+            #if new_name not in self.orientation_params:
+            self.details[new_name]= detail
+        for name ,detail in self.p_model2.details.iteritems():
+            new_name = "p2_" + name
+            #if new_name not in self.orientation_params:
+            self.details[new_name]= detail
+    def _set_scale_factor(self):
+        pass
+    def setParam(self, name, value):
+        # set param to this (p1, p2) model
+        self._setParamHelper(name, value)
+        ## setParam to p model
+        model_pre = ''
+        new_name = ''
+        name_split = name.split('_', 1)
+        if len(name_split) == 2:
+            model_pre = name.split('_', 1)[0]
+            new_name = name.split('_', 1)[1]
+        if model_pre == "p1":
+            if new_name in self.p_model1.getParamList():
+                self.p_model1.setParam(new_name, value)
+        elif model_pre == "p2":
+             if new_name in self.p_model2.getParamList():
+                self.p_model2.setParam(new_name, value)
+        elif name == 'scale_factor':
+            self.params['scale_factor'] = value
+        else:
+            raise ValueError, "Model does not contain parameter %s" % name
+    def getParam(self, name):
+        # Look for dispersion parameters
+        toks = name.split('.')
+        if len(toks)==2:
+            for item in self.dispersion.keys():
+                # 2D not supported
+                if item.lower()==toks[0].lower():
+                    for par in self.dispersion[item]:
+                        if par.lower() == toks[1].lower():
+                            return self.dispersion[item][par]
+        else:
+            # Look for standard parameter
+            for item in self.params.keys():
+                if item.lower()==name.lower():
+                    return self.params[item]
+        return
+        #raise ValueError, "Model does not contain parameter %s" % name
+    def _setParamHelper(self, name, value):
+        # Look for dispersion parameters
+        toks = name.split('.')
+        if len(toks)== 2:
+            for item in self.dispersion.keys():
+                if item.lower()== toks[0].lower():
+                    for par in self.dispersion[item]:
+                        if par.lower() == toks[1].lower():
+                            self.dispersion[item][par] = value
+                            return
+        else:
+            # Look for standard parameter
+            for item in self.params.keys():
+                if item.lower()== name.lower():
+                    self.params[item] = value
+                    return
+        raise ValueError, "Model does not contain parameter %s" % name
+    def _set_fixed_params(self):
+        self.fixed = []
+        for item in self.p_model1.fixed:
+            new_item = "p1" + item
+            self.fixed.append(new_item)
+        for item in self.p_model2.fixed:
+            new_item = "p2" + item
+            self.fixed.append(new_item)
+        self.fixed.sort()
+    def run(self, x = 0.0):
+        self._set_scale_factor()
+        return self.params['scale_factor'] %s \
+(self.p_model1.run(x) %s self.p_model2.run(x))
+    def runXY(self, x = 0.0):
+        self._set_scale_factor()
+        return self.params['scale_factor'] %s \
+(self.p_model1.runXY(x) %s self.p_model2.runXY(x))
+    ## Now (May27,10) directly uses the model eval function
+    ## instead of the for-loop in Base Component.
+    def evalDistribution(self, x = []):
+        self._set_scale_factor()
+        return self.params['scale_factor'] %s \
+(self.p_model1.evalDistribution(x) %s \
+self.p_model2.evalDistribution(x))
+    def set_dispersion(self, parameter, dispersion):
+        value= None
+        new_pre = parameter.split("_", 1)[0]
+        new_parameter = parameter.split("_", 1)[1]
+        try:
+            if new_pre == 'p1' and \
+new_parameter in self.p_model1.dispersion.keys():
+                value= self.p_model1.set_dispersion(new_parameter, dispersion)
+            if new_pre == 'p2' and \
+new_parameter in self.p_model2.dispersion.keys():
+                value= self.p_model2.set_dispersion(new_parameter, dispersion)
+            self._set_dispersion()
+            return value
+        except:
+            raise
+    def fill_description(self, p_model1, p_model2):
+        description = ""
+        description += "This model gives the summation or multiplication of"
+        description += "%s and %s. "% ( p_model1.name, p_model2.name )
+        self.description += description
+if __name__ == "__main__":
+    m1= Model()
+    #m1.setParam("p1_scale", 25)
+    #m1.setParam("p1_length", 1000)
+    #m1.setParam("p2_scale", 100)
+    #m1.setParam("p2_rg", 100)
+    out1 = m1.runXY(0.01)
+    m2= Model()
+    #m2.p_model1.setParam("scale", 25)
+    #m2.p_model1.setParam("length", 1000)
+    #m2.p_model2.setParam("scale", 100)
+    #m2.p_model2.setParam("rg", 100)
+    out2 = m2.p_model1.runXY(0.01) %s m2.p_model2.runXY(0.01)\n
+    print "My name is %s."% m1.name
+    print out1, " = ", out2
+    if out1 == out2:
+        print "===> Simple Test: Passed!"
+    else:
+        print "===> Simple Test: Failed!"
+from sasmodels.core import load_model_info
+from sasmodels.sasview_model import make_model_from_info
+model_info = load_model_info('{model1}{operator}{model2}')
+model_info.name = '{name}'{desc_line}
+Model = make_model_from_info(model_info)
 """
 if __name__ == "__main__":
 #    app = wx.PySimpleApp()

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

-                      r489f53a
+                      r2d9526d
             @param unsmeared_error: data error, rescaled to unsmeared model
         """
         number_finite = np.count_nonzero(np.isfinite(y))
         np.nan_to_num(y)
 …
                                          data_description=model.name,
                                          data_id=str(page_id) + " " + data.name)
+        plots_to_update = [] # List of plottables that have changed since last calculation
+        # Create the new theories
         if unsmeared_model is not None:
+            self.create_theory_1D(x, unsmeared_model, page_id, model, data, state,
+            unsmeared_model_plot = self.create_theory_1D(x, unsmeared_model,
+                                  page_id, model, data, state,
                                   data_description=model.name + " unsmeared",
                                   data_id=str(page_id) + " " + data.name + " unsmeared")
+            plots_to_update.append(unsmeared_model_plot)
             if unsmeared_data is not None and unsmeared_error is not None:
+                self.create_theory_1D(x, unsmeared_data, page_id, model, data, state,
+                unsmeared_data_plot = self.create_theory_1D(x, unsmeared_data,
+                                      page_id, model, data, state,
                                       data_description="Data unsmeared",
                                       data_id="Data  " + data.name + " unsmeared",
                                       dy=unsmeared_error)
+        # Comment this out until we can get P*S models with correctly populated parameters
+        #if sq_model is not None and pq_model is not None:
+        #    self.create_theory_1D(x, sq_model, page_id, model, data, state,
+        #                          data_description=model.name + " S(q)",
+        #                          data_id=str(page_id) + " " + data.name + " S(q)")
+        #    self.create_theory_1D(x, pq_model, page_id, model, data, state,
+        #                          data_description=model.name + " P(q)",
+        #                          data_id=str(page_id) + " " + data.name + " P(q)")
+                plots_to_update.append(unsmeared_data_plot)
+        if sq_model is not None and pq_model is not None:
+            sq_id = str(page_id) + " " + data.name + " S(q)"
+            sq_plot = self.create_theory_1D(x, sq_model, page_id, model, data, state,
+                                  data_description=model.name + " S(q)",
+                                  data_id=sq_id)
+            plots_to_update.append(sq_plot)
+            pq_id = str(page_id) + " " + data.name + " P(q)"
+            pq_plot = self.create_theory_1D(x, pq_model, page_id, model, data, state,
+                                  data_description=model.name + " P(q)",
+                                  data_id=pq_id)
+            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,
+                                              action='update'))
         current_pg = self.fit_panel.get_page_by_id(page_id)

src/sas/sasgui/perspectives/fitting/media/fitting_help.rst

-                      r5295cf5
+                      rca383a0
 the :ref:`Advanced_Plugin_Editor` .
+**SasView version 4.2** made it possible to specify whether a plugin created with
+the *New Plugin Model* dialog is actually a form factor P(Q) or a structure factor
+S(Q). To do this, simply add one or other of the following lines under the *import*
+statements.
+For a form factor::
+     form_factor = True
+or for a structure factor::
+     structure_factor = True
+If the plugin is a structure factor it is *also* necessary to add two variables to
+the parameter list::
+     parameters = [
+                     ['radius_effective', '', 1, [0.0, numpy.inf], 'volume', ''],
+                     ['volfraction', '', 1, [0.0, 1.0], '', ''],
+                     [...],
+and to the declarations of the functions Iq and Iqxy:::
+     def Iq(x , radius_effective, volfraction, ...):
+     def Iqxy(x, y, radius_effective, volfraction, ...):
+Such a plugin should then be available in the S(Q) drop-down box on a FitPage (once
+a P(Q) model has been selected).
 Sum|Multi(p1,p2)
 ^^^^^^^^^^^^^^^^
 …
 or::
      Plugin Model = scale_factor * model_1 /* model_2 + background
+     Plugin Model = scale_factor * (model1 * model2) + background
 In the *Easy Sum/Multi Editor* give the new model a function name and brief
 description (to appear under the *Details* button on the *FitPage*). Then select
 two existing models, as p1 and p2, and the required operator, '+' or '*' between
+them. Finally, click the *Apply* button to generate the model and then click *Close*.
+Any changes to a plugin model generated in this way only become effective *after* it is re-selected from the model drop-down menu on the FitPage.
+them. Finally, click the *Apply* button to generate and test the model and then click *Close*.
+Any changes to a plugin model generated in this way only become effective *after* it is re-selected
+from the plugin models drop-down menu on the FitPage. If the model is not listed you can force a
+recompilation of the plugins by selecting *Fitting* > *Plugin Model Operations* > *Load Plugin Models*.
+**SasView version 4.2** introduced a much simplified and more extensible structure for plugin models
+generated through the Easy Sum/Multi Editor. For example, the code for a combination of a sphere model
+with a power law model now looks like this::
+     from sasmodels.core import load_model_info
+     from sasmodels.sasview_model import make_model_from_info
+     model_info = load_model_info('sphere+power_law')
+     model_info.name = 'MyPluginModel'
+     model_info.description = 'sphere + power_law'
+     Model = make_model_from_info(model_info)
+To change the models or operators contributing to this plugin it is only necessary to edit the string
+in the brackets after *load_model_info*, though it would also be a good idea to update the model name
+and description too!!!
+The model specification string can handle multiple models and combinations of operators (+ or *) which
+are processed according to normal conventions. Thus 'model1+model2*model3' would be valid and would
+multiply model2 by model3 before adding model1. In this example, parameters in the *FitPage* would be
+prefixed A (for model2), B (for model3) and C (for model1). Whilst this might appear a little
+confusing, unless you were creating a plugin model from multiple instances of the same model the parameter
+assignments ought to be obvious when you load the plugin.
+If you need to include another plugin model in the model specification string, just prefix the name of
+that model with *custom*. For instance::
+     sphere+custom.MyPluginModel
+To create a P(Q)*\S(Q) model use the @ symbol instead of * like this::
+     sphere@hardsphere
+This streamlined approach to building complex plugin models from existing library models, or models
+available on the *Model Marketplace*, also permits the creation of P(Q)*\S(Q) plugin models, something
+that was not possible in earlier versions of SasView.
 .. _Advanced_Plugin_Editor:
 …
 .. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
+.. _Batch_Fit_Mode:
 Batch Fit Mode
 --------------
 …
      Example: radius [2 : 5] , radius [10 : 25]
+.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
+.. note::  This help document was last changed by Steve King, 10Oct2016
+.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
+Combined Batch Fit Mode
+-----------------------
+The purpose of the Combined Batch Fit is to allow running two or more batch
+fits in sequence without overwriting the output table of results.  This may be
+of interest for example if one is fitting a series of data sets where there is
+a shape change occurring in the series that requires changing the model part
+way through the series; for example a sphere to rod transition.  Indeed the
+regular batch mode does not allow for multiple models and requires all the
+files in the series to be fit with single model and set of parameters.  While
+it is of course possible to just run part of the series as a batch fit using
+model one followed by running another batch fit on the rest of the series with
+model two (and/or model three etc), doing so will overwrite the table of
+outputs from the previous batch fit(s).  This may not be desirable if one is
+interested in comparing the parameters: for example the sphere radius of set
+one and the cylinder radius of set two.
+Method
+^^^^^^
+In order to use the *Combined Batch Fit*, first load all the data needed as
+described in :ref:`Loading_data`. Next start up two or more *BatchPage* fits
+following the instructions in :ref:`Batch_Fit_Mode` but **DO NOT PRESS FIT**.
+At this point the *Combine Batch Fit* menu item under the *Fitting menu* should
+be active (if there is one or no *BatchPage* the menu item will be greyed out
+and inactive).  Clicking on *Combine Batch Fit* will bring up a new panel,
+similar to the *Const & Simult Fit* panel. In this case there will be a
+checkbox for each *BatchPage* instead of each *FitPage* that should be included
+in the fit.  Once all are selected, click the Fit button on
+the *BatchPage* to run each batch fit in *sequence*
+.. image:: combine_batch_page.png
+The batch table will then pop up at the end as for the case of the simple Batch
+Fitting with the following caveats:
+.. note::
+   The order matters.  The parameters in the table will be taken from the model
+   used in the first *BatchPage* of the list.  Any parameters from the
+   second and later *BatchPage* s that have the same name as a parameter in the
+   first will show up allowing for plotting of that parameter across the
+   models. The other parameters will not be available in the grid.
+.. note::
+   a corralary of the above is that currently models created as a sum|multiply
+   model will not work as desired because the generated model parameters have a
+   p#_ appended to the beginning and thus radius and p1_radius will not be
+   recognized as the same parameter.
+.. image:: combine_batch_grid.png
+In the example shown above the data is a time series with a shifting peak.
+The first part of the series was fitted using the *broad_peak* model, while
+the rest of the data were fit using the *gaussian_peak* model. Unfortunately the
+time is not listed in the file but the file name contains the information. As
+described in :ref:`Grid_Window`, a column can be added manually, in this case
+called time, and the peak position plotted against time.
+.. image:: combine_batch_plot.png
+Note the discontinuity in the peak position.  This reflects the fact that the
+Gaussian fit is a rather poor model for the data and is not actually
+finding the peak.
+.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
+.. note::  This help document was last changed by Paul Butler, 10 September

src/sas/sasgui/perspectives/fitting/media/plugin.rst

-                      r72100ee
+                      re081946
 * By writing a model from scratch outside of SasView (only recommended for
   code monkeys!)
+**What follows below is quite technical. If you just want a helping hand to get
+started creating your own models see** :ref:`Adding_your_own_models`.
 Overview

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

-                      r7432acb
+                      r0f9ea1c
                     (self.data.qy_data * self.data.qy_data))
         # For theory, qmax is based on 1d qmax
+        # 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)
 …
                 self.data.qy_data[index_model]
             ])
+        output = np.zeros(len(self.data.qx_data))
+        # Initialize output to NaN so masked elements do not get plotted.
+        output = np.empty_like(self.data.qx_data)
         # output default is None
         # This method is to distinguish between masked
         #point(nan) and data point = 0.
         output = output / output
+        output[:] = np.NaN
         # set value for self.mask==True, else still None to Plottools
         output[index_model] = value
 …
             output[index] = self.model.evalDistribution(self.data.x[index])
+        x=self.data.x[index]
+        y=output[index]
         sq_values = None
         pq_values = None
-        s_model = None
-        p_model = None
         if isinstance(self.model, MultiplicationModel):
             s_model = self.model.s_model
             p_model = self.model.p_model
+        elif hasattr(self.model, "get_composition_models"):
+            p_model, s_model = self.model.get_composition_models()
+        if p_model is not None and s_model is not None:
+            sq_values = np.zeros((len(self.data.x)))
+            pq_values = np.zeros((len(self.data.x)))
+            sq_values[index] = s_model.evalDistribution(self.data.x[index])
+            pq_values[index] = p_model.evalDistribution(self.data.x[index])
+            sq_values = s_model.evalDistribution(x)
+            pq_values = p_model.evalDistribution(x)
+        elif hasattr(self.model, "calc_composition_models"):
+            results = self.model.calc_composition_models(x)
+            if results is not None:
+                pq_values, sq_values = results
         elapsed = time.time() - self.starttime
         self.complete(x=self.data.x[index], y=output[index],
+        self.complete(x=x, y=y,
                       page_id=self.page_id,
                       state=self.state,

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

-                      r959eb01
+                      ra9f9ca4
 """
     Simultaneous fit page
+    Simultaneous or Batch fit page
 """
+# 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
+# if not batch_on:
+#     xxxx
+# else:
+#     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
+# batch page inherit.
+#
+#            04/09/2017   --PDB
 import sys
 from collections import namedtuple
 …
         # General Help button
         self.btHelp = wx.Button(self, wx.ID_HELP, 'HELP')
+        self.btHelp.SetToolTipString("Simultaneous/Constrained Fitting help.")
+        if self.batch_on:
+            self.btHelp.SetToolTipString("Combined Batch Fitting help.")
+        else:
+            self.btHelp.SetToolTipString("Simultaneous/Constrained Fitting help.")
         self.btHelp.Bind(wx.EVT_BUTTON, self._on_help)
 …
     """
         _TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html"
+        _PageAnchor = "#simultaneous-fit-mode"
+        _doc_viewer = DocumentationWindow(self, self.ID_DOC, _TreeLocation,
+        if not self.batch_on:
+            _PageAnchor = "#simultaneous-fit-mode"
+            _doc_viewer = DocumentationWindow(self, self.ID_DOC, _TreeLocation,
                                           _PageAnchor,
                                           "Simultaneous/Constrained Fitting Help")
+        else:
+            _PageAnchor = "#combined-batch-fit-mode"
+            _doc_viewer = DocumentationWindow(self, self.ID_DOC, _TreeLocation,
+                                          _PageAnchor,
+                                          "Combined Batch Fit Help")
     def set_manager(self, manager):

src/sas/sasgui/plottools/plottables.py

-                      r45dffa69
+                      r2d9526d
     def replace(self, plottable):
         """Replace an existing plottable from the graph"""
+        selected_color = None
+        # If the user has set a custom color, ensure the new plot is the same color
+        selected_color = plottable.custom_color
         selected_plottable = None
         for p in self.plottables.keys():
             if plottable.id == p.id:
                 selected_plottable = p
+                selected_color = self.plottables[p]
+                if selected_color is None:
+                    selected_color = self.plottables[p]
                 break
         if  selected_plottable is not None and selected_color is not None:
+        if selected_plottable is not None and selected_color is not None:
             del self.plottables[selected_plottable]
+            plottable.custom_color = selected_color
             self.plottables[plottable] = selected_color

src/sas/sasgui/init.py

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

src/sas/sasgui/guiframe/CategoryInstaller.py

-                      r235f514
+                      r914ba0a
 import logging
 from collections import defaultdict, OrderedDict
+from sas.sasgui import get_user_dir
 USER_FILE = 'categories.json'
 …
     @staticmethod
-    def _get_home_dir():
-        """
-        returns the users sasview config dir
-        """
-        return os.path.join(os.path.expanduser("~"), ".sasview")
-    @staticmethod
     def _regenerate_model_dict(master_category_dict):
         """
 …
         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
 …
         returns the user data file, eg .sasview/categories.json.json
         """
         return os.path.join(CategoryInstaller._get_home_dir(), USER_FILE)
+        return os.path.join(get_user_dir(), USER_FILE)
     @staticmethod
 …
                 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)

src/sas/sasgui/guiframe/aboutbox.py

-                      r959eb01
+                      r914ba0a
 import os.path
 import os
+try:
+    # Try to find a local config
+    import imp
+    path = os.getcwd()
+    if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \
+      (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))):
+        fObj, path, descr = imp.find_module('local_config', [path])
+        config = imp.load_module('local_config', fObj, path, descr)
+    else:
+        # Try simply importing local_config
+        import local_config as config
+except:
+    # Didn't find local config, load the default
+    import config
+from sas.sasgui import get_local_config
+config = get_local_config()
 def launchBrowser(url):
     """
     Launches browser and opens specified url
     In some cases may require BROWSER environment variable to be set up.
     :param url: URL to open
     """
     import webbrowser
 …
     """
     "About" Dialog
     Shows product name, current version, authors, and link to the product page.
     Current version is taken from version.py
     """
+    """
     def __init__(self, *args, **kwds):
 …
         kwds["style"] = wx.DEFAULT_DIALOG_STYLE
         wx.Dialog.__init__(self, *args, **kwds)
         file_dir = os.path.dirname(__file__)
         # Mac doesn't display images with transparent background so well,
         # keep it for Windows
         image = file_dir + "/images/angles_flat.png"
         if os.path.isfile(config._corner_image):
             image = config._corner_image
 …
         else:
             self.bitmap_logo = wx.StaticBitmap(self, -1, wx.Bitmap(image))
         self.label_title = wx.StaticText(self, -1, config.__appname__)
         self.label_version = wx.StaticText(self, -1, "")
 …
         #self.bitmap_button_danse = wx.BitmapButton(self, -1, wx.NullBitmap)
         self.bitmap_button_msu = wx.BitmapButton(self, -1, wx.NullBitmap)
         self.bitmap_button_isis = wx.BitmapButton(self, -1, wx.NullBitmap)
         self.bitmap_button_ess = wx.BitmapButton(self, -1, wx.NullBitmap)
 …
         self.bitmap_button_tudelft = wx.BitmapButton(self, -1, wx.NullBitmap)
         self.bitmap_button_dls = wx.BitmapButton(self, -1, wx.NullBitmap)
         self.static_line_3 = wx.StaticLine(self, -1)
         self.button_OK = wx.Button(self, wx.ID_OK, "OK")
 …
         self.__set_properties()
         self.__do_layout()
         self.Bind(wx.EVT_BUTTON, self.onNistLogo, self.bitmap_button_nist)
         self.Bind(wx.EVT_BUTTON, self.onUmdLogo, self.bitmap_button_umd)
 …
         random.shuffle(config._authors)
         strLabel = ", ".join(config._authors)
         # display version and svn revison numbers
         verwords = config.__version__.split('.')
 …
         self.label_version.SetLabel(config.__version__)#(version)
         self.label_svnrevision.SetLabel(build_num)
         # set bitmaps for logo buttons
         image = file_dir + "/images/nist_logo.png"
         if os.path.isfile(config._nist_logo):
             image = config._nist_logo
         logo = wx.Bitmap(image)
+        logo = wx.Bitmap(image)
         self.bitmap_button_nist.SetBitmapLabel(logo)
         image = file_dir + "/images/umd_logo.png"
         if os.path.isfile(config._umd_logo):
             image = config._umd_logo
         logo = wx.Bitmap(image)
+        logo = wx.Bitmap(image)
         self.bitmap_button_umd.SetBitmapLabel(logo)
 …
         if os.path.isfile(config._ornl_logo):
             image = config._ornl_logo
         logo = wx.Bitmap(image)
+        logo = wx.Bitmap(image)
         self.bitmap_button_ornl.SetBitmapLabel(logo)
 …
         if os.path.isfile(config._sns_logo):
             image = config._sns_logo
         logo = wx.Bitmap(image)
+        logo = wx.Bitmap(image)
         self.bitmap_button_sns.SetBitmapLabel(logo)
         image = file_dir + "/images/nsf_logo.png"
         if os.path.isfile(config._nsf_logo):
             image = config._nsf_logo
         logo = wx.Bitmap(image)
+        logo = wx.Bitmap(image)
         self.bitmap_button_nsf.SetBitmapLabel(logo)
 …
         logo = wx.Bitmap(image)
         self.bitmap_button_msu.SetBitmapLabel(logo)
         image = file_dir + "/images/isis_logo.png"
         if os.path.isfile(config._isis_logo):
             image = config._isis_logo
         logo = wx.Bitmap(image)
+        logo = wx.Bitmap(image)
         self.bitmap_button_isis.SetBitmapLabel(logo)
 …
         logo = wx.Bitmap(image)
         self.bitmap_button_ess.SetBitmapLabel(logo)
         image = file_dir + "/images/ill_logo.png"
         if os.path.isfile(config._ill_logo):
 …
         logo = wx.Bitmap(image)
         self.bitmap_button_ill.SetBitmapLabel(logo)
         image = file_dir + "/images/ansto_logo.png"
         if os.path.isfile(config._ansto_logo):
 …
         logo = wx.Bitmap(image)
         self.bitmap_button_ansto.SetBitmapLabel(logo)
         image = file_dir + "/images/tudelft_logo.png"
         if os.path.isfile(config._tudelft_logo):
 …
         logo = wx.Bitmap(image)
         self.bitmap_button_tudelft.SetBitmapLabel(logo)
         image = file_dir + "/images/dls_logo.png"
         if os.path.isfile(config._dls_logo):
 …
         logo = wx.Bitmap(image)
         self.bitmap_button_dls.SetBitmapLabel(logo)
         # resize dialog window to fit version number nicely
         if wx.VERSION >= (2, 7, 2, 0):
 …
             size = [self.GetBestFittingSize()[0], self.GetSize()[1]]
         self.Fit()
     def __set_properties(self):
         """
 …
         sizer_main.Add(self.static_line_2, 0, wx.EXPAND, 0)
         sizer_logos.Add(self.bitmap_button_msu, 0,
+        sizer_logos.Add(self.bitmap_button_msu, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         #sizer_logos.Add(self.bitmap_button_danse, 0,
         #                wx.LEFT|wx.ADJUST_MINSIZE, 2)
         #sizer_logos.Add(self.bitmap_button_nsf, 0,
+        #sizer_logos.Add(self.bitmap_button_nsf, 0,
         #                wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_umd, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_nist, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         #sizer_logos.Add(self.bitmap_button_sns, 0,
+        sizer_logos.Add(self.bitmap_button_umd, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_nist, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        #sizer_logos.Add(self.bitmap_button_sns, 0,
         #                wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_ornl, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_isis, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_ess, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_ill, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_ansto, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_tudelft, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add(self.bitmap_button_dls, 0,
                         wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_ornl, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_isis, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_ess, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_ill, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_ansto, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_tudelft, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
+        sizer_logos.Add(self.bitmap_button_dls, 0,
+                        wx.LEFT|wx.ADJUST_MINSIZE, 2)
         sizer_logos.Add((10, 50), 0, wx.ADJUST_MINSIZE, 0)
         sizer_main.Add(sizer_logos, 0, wx.EXPAND, 0)
         sizer_main.Add(self.static_line_3, 0, wx.EXPAND, 0)
         sizer_button.Add((20, 40), 1, wx.EXPAND|wx.ADJUST_MINSIZE, 0)
         sizer_button.Add(self.button_OK, 0,
+        sizer_button.Add(self.button_OK, 0,
                          wx.RIGHT|wx.ADJUST_MINSIZE|wx.CENTER, 10)
         sizer_main.Add(sizer_button, 0, wx.EXPAND, 0)
 …
         # end wxGlade
     def onNistLogo(self, event):
+    def onNistLogo(self, event):
         """
         """
 …
         launchBrowser(config._nist_url)
         event.Skip()
     def onUmdLogo(self, event):
+    def onUmdLogo(self, event):
         """
         """
 …
         launchBrowser(config._umd_url)
         event.Skip()
     def onOrnlLogo(self, event):
+    def onOrnlLogo(self, event):
         """
         """
 …
         launchBrowser(config._ornl_url)
         event.Skip()
     def onSnsLogo(self, event):
+    def onSnsLogo(self, event):
         """
         """
 …
         launchBrowser(config._sns_url)
         event.Skip()
     def onNsfLogo(self, event):
+    def onNsfLogo(self, event):
         """
         """
 …
     def onUTLogo(self, event):
         """
         """
+        """
         # wxGlade: DialogAbout.<event_handler>
         launchBrowser(config._inst_url)
         event.Skip()
     def onIsisLogo(self, event):
+    def onIsisLogo(self, event):
         """
         """
 …
     def onIllLogo(self, event):
         """
         """
+        """
         # wxGlade: DialogAbout.<event_handler>
         launchBrowser(config._ill_url)
 …
     def onAnstoLogo(self, event):
         """
         """
+        """
         # wxGlade: DialogAbout.<event_handler>
         launchBrowser(config._ansto_url)
 …
     def onTudelftLogo(self, event):
         """
         """
+        """
         # wxGlade: DialogAbout.<event_handler>
         launchBrowser(config._tudelft_url)
 …
     def onDlsLogo(self, event):
         """
         """
+        """
         # wxGlade: DialogAbout.<event_handler>
         launchBrowser(config._dls_url)
 …
     app = MyApp(0)
     app.MainLoop()
 ##### end of testing code #####################################################
+##### end of testing code #####################################################

src/sas/sasgui/guiframe/acknowledgebox.py

-                      r74c8cd0
+                      r914ba0a
 import wx.lib.hyperlink
 from wx.lib.expando import ExpandoTextCtrl
-import random
-import os.path
-import os
-try:
-    # Try to find a local config
-    import imp
-    path = os.getcwd()
-    if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \
-      (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))):
-        fObj, path, descr = imp.find_module('local_config', [path])
-        config = imp.load_module('local_config', fObj, path, descr)
-    else:
-        # Try simply importing local_config
-        import local_config as config
-except:
-    # Didn't find local config, load the default
-    import config
+from sas.sasgui import get_local_config
+config = get_local_config()
 class DialogAcknowledge(wx.Dialog):

src/sas/sasgui/guiframe/config.py

-                      ra1b8fee
+                      rc6bdb3b
 """
     Application settings
+Application settings
 """
 from __future__ import print_function
 …
 import time
 import os
+import logging
 from sas.sasgui.guiframe.gui_style import GUIFRAME
 import sas.sasview
-import logging
 logger = logging.getLogger(__name__)
 …
 _ansto_logo = os.path.join(icon_path, "ansto_logo.png")
 _tudelft_logo = os.path.join(icon_path, "tudelft_logo.png")
+_dls_logo = os.path.join(icon_path, "dls_logo.png")
 _nsf_logo = os.path.join(icon_path, "nsf_logo.png")
 _danse_logo = os.path.join(icon_path, "danse_logo.png")
 …
 SAS_OPENCL = None
+# Time out for updating sasview
+UPDATE_TIMEOUT = 2
 def printEVT(message):
     if __EVT_DEBUG__:

src/sas/sasgui/guiframe/customdir.py

-                      r959eb01
+                      rc6bdb3b
 # Setup and find Custom config dir
+from __future__ import print_function
 import os.path
+import logging
 import shutil
+CONF_DIR = 'config'
+APPLICATION_NAME = 'sasview'
+from sasmodels.custom import load_module_from_path
+def _find_usersasview_dir():
+    """
+    Find and return user/.sasview dir
+    """
+    return os.path.join(os.path.expanduser("~"), ("." + APPLICATION_NAME))
+from sas.sasgui import get_custom_config_path, get_app_dir
+def _find_customconf_dir():
+    """
+    Find path of the config directory.
+    The plugin directory is located in the user's home directory.
+    """
+    u_dir = _find_usersasview_dir()
+    return os.path.join(u_dir, CONF_DIR)
+logger = logging.getLogger(__name__)
+def _setup_conf_dir(path):
+_config_cache = None
+def setup_custom_config():
     """
     Setup the custom config dir and cat file
     """
+    conf_dir = _find_customconf_dir()
+    # If the plugin directory doesn't exist, create it
+    if not os.path.isdir(conf_dir):
+        os.makedirs(conf_dir)
+    config_file = os.path.join(conf_dir, "custom_config.py")
+    # Place example user models as needed
+    try:
+        if not os.path.isfile(config_file):
+            shutil.copyfile(os.path.join(path, "custom_config.py"), config_file)
+        #Adding SAS_OPENCL if it doesn't exist in the config file
+        # - to support backcompability
+        if not "SAS_OPENCL" in open(config_file).read():
+            open(config_file,"a+").write("SAS_OPENCL = \"None\"\n")
+    except:
+        # Check for data path next to exe/zip file.
+        #Look for maximum n_dir up of the current dir to find plugins dir
+        n_dir = 12
+        is_dir = False
+        f_dir = path
+        for i in range(n_dir):
+            if i > 1:
+                f_dir, _ = os.path.split(f_dir)
+            temp_path = os.path.join(f_dir, "custom_config.py")
+            if os.path.isfile(temp_path):
+                shutil.copyfile(temp_path, config_file)
+                is_dir = True
+                break
+        if not is_dir:
+            raise
+    return conf_dir
+    global _config_cache
+    if not _config_cache:
+        _config_cache = _setup_custom_config()
+    return _config_cache
+class SetupCustom(object):
+    """
+    implement custom config dir
+    """
+    def find_dir(self):
+        return _find_customconf_dir()
+    def setup_dir(self, path):
+        return _setup_conf_dir(path)
+def _setup_custom_config():
+    path = get_custom_config_path()
+    if not os.path.isfile(path):
+        try:
+            # if the custom config file does not exist, copy the default from
+            # the app dir
+            shutil.copyfile(os.path.join(get_app_dir(), "custom_config.py"),
+                            path)
+        except Exception:
+            logger.error("Could not copy default custom config.")
+    #Adding SAS_OPENCL if it doesn't exist in the config file
+    # - to support backcompability
+    if not "SAS_OPENCL" in open(path).read():
+        try:
+            open(config_file, "a+").write("SAS_OPENCL = \"None\"\n")
+        except Exception:
+            logger.error("Could not update custom config with SAS_OPENCL.")
+    custom_config = _load_config(path)
+    return custom_config
+def _load_config(path):
+    if os.path.exists(path):
+        try:
+            module = load_module_from_path('sas.sasview.custom_config', path)
+            logger.info("GuiManager loaded %s", path)
+            return module
+        except Exception as exc:
+            logger.error("Error loading %s: %s", path, exc)
+    from sas.sasview import custom_config
+    logger.info("GuiManager custom_config defaults to sas.sasview.custom_config")
+    return custom_config

src/sas/sasgui/guiframe/data_panel.py

-                      ra1b8fee
+                      rc6bdb3b
 from sas.sasgui.guiframe.local_perspectives.plotting.SimplePlot \
     import PlotFrame as QucikPlotDialog
+import sas.sasgui.guiframe.config as config
+from sas.sasgui import get_local_config
+config = get_local_config()
 # Check version

src/sas/sasgui/guiframe/documentation_window.py

-                      r959eb01
+                      rd66dbcc
 import os
 import logging
-import wx
 import webbrowser
 import urllib
 import sys
+import wx
+try:
+    import wx.html2 as html
+    WX_SUPPORTS_HTML2 = True
+except:
+    WX_SUPPORTS_HTML2 = False
+from sas.sasgui import get_app_dir
 logger = logging.getLogger(__name__)
 SPHINX_DOC_ENV = "SASVIEW_DOC_PATH"
-WX_SUPPORTS_HTML2 = True
-try:
-    import wx.html2 as html
-except:
-    WX_SUPPORTS_HTML2 = False
-from gui_manager import get_app_dir
 class DocumentationWindow(wx.Frame):

src/sas/sasgui/guiframe/gui_manager.py

-                      r2f22db9
+                      r914ba0a
 import re
 import logging
-import httplib
 import traceback
 import urllib
-import urllib2
 import json
+from matplotlib import _pylab_helpers
+from sas.sasgui import get_local_config, get_app_dir, get_user_dir
 from sas.sasgui.guiframe.events import EVT_CATEGORY
 from sas.sasgui.guiframe.events import EVT_STATUS
 …
 from sas.sascalc.dataloader.loader import Loader
 from sas.sasgui.guiframe.proxy import Connection
 from matplotlib import _pylab_helpers
+from sas.sasgui.guiframe.customdir import setup_custom_config
 logger = logging.getLogger(__name__)
 warnings.simplefilter("ignore")
+def get_app_dir():
+    """
+        The application directory is the one where the default custom_config.py
+        file resides.
+        :returns: app_path - the path to the applicatin directory
+    """
+    # First, try the directory of the executable we are running
+    app_path = sys.path[0]
+    if os.path.isfile(app_path):
+        app_path = os.path.dirname(app_path)
+    if os.path.isfile(os.path.join(app_path, "custom_config.py")):
+        app_path = os.path.abspath(app_path)
+        logger.info("Using application path: %s", app_path)
+        return app_path
+    # Next, try the current working directory
+    if os.path.isfile(os.path.join(os.getcwd(), "custom_config.py")):
+        logger.info("Using application path: %s", os.getcwd())
+        return os.path.abspath(os.getcwd())
+    # Finally, try the directory of the sasview module
+    # TODO: gui_manager will have to know about sasview until we
+    # clean all these module variables and put them into a config class
+    # that can be passed by sasview.py.
+    logger.debug(sys.executable)
+    logger.debug(str(sys.argv))
+    from sas import sasview as sasview
+    app_path = os.path.dirname(sasview.__file__)
+    logger.debug("Using application path: %s", app_path)
+    return app_path
+def get_user_directory():
+    """
+        Returns the user's home directory
+    """
+    userdir = os.path.join(os.path.expanduser("~"), ".sasview")
+    if not os.path.isdir(userdir):
+        os.makedirs(userdir)
+    return userdir
+def _find_local_config(file, path):
+    """
+        Find configuration file for the current application
+    """
+    config_module = None
+    fObj = None
+    try:
+        fObj, path_config, descr = imp.find_module(file, [path])
+        config_module = imp.load_module(file, fObj, path_config, descr)
+    except:
+        logger.error("Error loading %s/%s: %s" % (path, file, sys.exc_value))
+    finally:
+        if fObj is not None:
+            fObj.close()
+    logger.debug("GuiManager loaded %s/%s" % (path, file))
+    return config_module
+# Get APP folder
+PATH_APP = get_app_dir()
+DATAPATH = PATH_APP
+# GUI always starts from the App folder
+# os.chdir(PATH_APP)
+# Read in the local config, which can either be with the main
+# application or in the installation directory
+config = _find_local_config('local_config', PATH_APP)
+if config is None:
+    config = _find_local_config('local_config', os.getcwd())
+    if config is None:
+        # Didn't find local config, load the default
+        import sas.sasgui.guiframe.config as config
+        logger.debug("using default local_config")
+    else:
+        logger.debug("found local_config in %s" % os.getcwd())
+else:
+    logger.debug("found local_config in %s" % PATH_APP)
+from sas.sasgui.guiframe.customdir import SetupCustom
+c_conf_dir = SetupCustom().setup_dir(PATH_APP)
+custom_config = _find_local_config('custom_config', c_conf_dir)
+if custom_config is None:
+    custom_config = _find_local_config('custom_config', os.getcwd())
+    if custom_config is None:
+        msgConfig = "Custom_config file was not imported"
+        logger.debug(msgConfig)
+    else:
+        logger.debug("using custom_config in %s" % os.getcwd())
+else:
+    logger.debug("using custom_config from %s" % c_conf_dir)
+config = get_local_config()
+custom_config = setup_custom_config()
 # read some constants from config
 …
         DEFAULT_OPEN_FOLDER = os.path.abspath(open_folder)
     else:
         DEFAULT_OPEN_FOLDER = PATH_APP
+        DEFAULT_OPEN_FOLDER = get_app_dir()
     SAS_OPENCL = custom_config.SAS_OPENCL
 except:
 …
     DEFAULT_PERSPECTIVE = None
     CLEANUP_PLOT = False
+    DEFAULT_OPEN_FOLDER = get_app_dir()
     DEFAULT_OPEN_FOLDER = PATH_APP
     SAS_OPENCL = None
 …
                 if os.path.isfile(ico_file):
                     self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO))
         self.path = PATH_APP
+        self.path = get_app_dir()
         self.application_name = APPLICATION_NAME
         # Application manager
 …
         try:
             fd = open(file_name, 'w')
         except:
+        except Exception:
             # On Permission denied: IOError
             temp_dir = get_user_directory()
+            temp_dir = get_user_dir()
             temp_file_name = os.path.join(temp_dir, name)
             fd = open(temp_file_name, 'w')
 …
             # want Analysis.  This is NOT an issue on the Mac which does not
             # have the extra Window menu item.
             #      March 2016 Code Camp  -- PDB
+            #      March 2016 Code Camp  -- PDB
             Tools_pos = self._menubar.FindMenu("Tools")
             self._menubar.Insert(Tools_pos+1, self._applications_menu,
 …
                 logger.info("Failed to connect to www.sasview.org")
         self._process_version(version_info, standalone=event is None)
     def _process_version(self, version_info, standalone=True):
 …
                 if basename.lower() in [app_py, app_exe, app_app, app_base]:
                     data_base = sys.argv[1]
                     input_file = os.path.normpath(os.path.join(DATAPATH,
+                    input_file = os.path.normpath(os.path.join(get_app_dir(),
                                                                data_base))
         if input_file is None:
 …
         # do it only the first time app loaded
         # delete unused model folder
         model_folder = os.path.join(PATH_APP, path)
+        model_folder = os.path.join(get_app_dir(), path)
         if os.path.exists(model_folder) and os.path.isdir(model_folder):
             if len(os.listdir(model_folder)) > 0:

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

-                      rdcb91cf
+                      r759a8ab
 from sas.sascalc.dataloader.loader import Loader
 from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException
+from sas.sasgui import get_local_config
 from sas.sasgui.guiframe.plugin_base import PluginBase
 from sas.sasgui.guiframe.events import StatusEvent
 from sas.sasgui.guiframe.gui_style import GUIFRAME
 from sas.sasgui.guiframe.gui_manager import DEFAULT_OPEN_FOLDER
+try:
+    # Try to find a local config
+    import imp
+    path = os.getcwd()
+    if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \
+        (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))):
+        fObj, path, descr = imp.find_module('local_config', [path])
+        config = imp.load_module('local_config', fObj, path, descr)
+    else:
+        # Try simply importing local_config
+        import local_config as config
+except:
+    # Didn't find local config, load the default
+    import sas.sasgui.guiframe.config as config
+if config is None:
+    import sas.sasgui.guiframe.config as config
+config = get_local_config()
 extension_list = []
 if config.APPLICATION_STATE_EXTENSION is not None:

src/sas/sasgui/guiframe/startup_configuration.py

-                      r7432acb
+                      r914ba0a
 ################################################################################
 #This software was developed by the University of Tennessee as part of the
 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
 #project funded by the US National Science Foundation.
+#project funded by the US National Science Foundation.
+#
 #See the license text in license.txt
 …
 #copyright 2009, University of Tennessee
 ################################################################################
+import os
+import copy
 import wx
+import os
+import sys
+import copy
+#import sas.sasgui.guiframe.gui_manager as gui
+from sas.sasgui.guiframe.events import StatusEvent
+from sas.sasgui import get_custom_config_path
+from sas.sasgui.guiframe.events import StatusEvent
 from sas.sasgui.guiframe.gui_style import GUIFRAME
 from sas.sasgui.guiframe import gui_manager as CURRENT
+from sas.sasgui.guiframe.customdir  import SetupCustom
 # default configuration
 DEFAULT_STRINGS = {'GUIFRAME_WIDTH':-1,
 …
     """
     def __init__(self, parent, gui, id=-1, title="Startup Setting"):
         wx.Dialog.__init__(self, parent, id, title,
+        wx.Dialog.__init__(self, parent, id, title,
                            size=(PANEL_WIDTH, PANEL_HEIGHT))
         # parent
         self.parent = parent
-        self.path = SetupCustom().find_dir()
         self._gui = gui
         # font size
+        # font size
         self.SetWindowVariant(variant=FONT_VARIANT)
         self.current_string = copy.deepcopy(CURRENT_STRINGS)
 …
         title_text = wx.StaticText(self, id=wx.NewId(), label='Set interface configuration')
         default_bt = wx.RadioButton(self, -1, 'Default View', (15, 30),
+        default_bt = wx.RadioButton(self, -1, 'Default View', (15, 30),
                                     style=wx.RB_GROUP)
         default_bt.Bind(wx.EVT_RADIOBUTTON, self.OnDefault)
 …
         note_txt = wx.StaticText(self, -1, msg, (15, 75))
         note_txt.SetForegroundColour("black")
         hbox = wx.BoxSizer(wx.HORIZONTAL)
         okButton = wx.Button(self, wx.ID_OK, 'Set', size=(70, 25))
         closeButton = wx.Button(self,wx.ID_CANCEL, 'Cancel', size=(70, 25))
+        closeButton = wx.Button(self, wx.ID_CANCEL, 'Cancel', size=(70, 25))
         hbox.Add(closeButton, 1, wx.RIGHT, 5)
         hbox.Add(okButton, 1, wx.RIGHT, 5)
 …
         self.SetSizer(vbox)
     def OnDefault(self, event=None):
         """
 …
         self.return_string = copy.deepcopy(DEFAULT_STRINGS)
         return self.return_string
     def OnCurrent(self, event=None):
         """
 …
                 p_size = CURRENT_STRINGS['PLOPANEL_WIDTH']
             self.current_string['PLOPANEL_WIDTH'] = p_size
             try:
                 control_frame = self.parent.get_current_perspective().frame
 …
                 self.current_string['CONTROL_WIDTH'] = -1
                 self.current_string['CONTROL_HEIGHT'] = -1
             data_pw, _ = self.parent.panels["data_panel"].frame.GetSizeTuple()
             if data_pw is None:
                 data_pw = CURRENT_STRINGS['DATAPANEL_WIDTH']
             self.current_string['DATAPANEL_WIDTH'] = data_pw
             #label = self.parent._data_panel_menu.GetText()
             label = self.parent.panels['data_panel'].frame.IsShown()
 …
             else:
                 self.current_string['DATALOADER_SHOW'] = False
             if self.parent._toolbar.IsShown():
                 self.current_string['TOOLBAR_SHOW'] = True
             else:
                 self.current_string['TOOLBAR_SHOW'] = False
             style = self._gui & GUIFRAME.FLOATING_PANEL
             if style == GUIFRAME.FLOATING_PANEL:
+            if style == GUIFRAME.FLOATING_PANEL:
                 self.current_string['FIXED_PANEL'] = False
             else:
                 self.current_string['FIXED_PANEL'] = True
             if self.parent.panels['default'].frame.IsShown():
                 self.current_string['WELCOME_PANEL_SHOW'] = True
 …
             self.current_string['DEFAULT_OPEN_FOLDER'] = location
                         #self.parent._default_save_location.ascii_letters
         except:
             raise
 …
         self.return_string = self.current_string
         return self.return_string
     def write_custom_config(self):
         """
+            Write custom configuration
+        """
+        fname = os.path.join(self.path, 'custom_config.py')
+        self.write_string(fname, self.return_string)
+    def write_string(self, fname, strings):
+        """
+        Write and Save file
+        """
+        try:
+            out_f =  open(fname,'w')
+        except :
+            raise  #RuntimeError, "Error: Can not change the configuration..."
+        out_f.write("#Application appearance custom configuration\n" )
+        for key, item in strings.iteritems():
+            if (key == 'DEFAULT_PERSPECTIVE') or \
+                (key == 'DEFAULT_OPEN_FOLDER' and item is not None):
+                out_f.write("%s = \"%s\"\n" % (key,str(item)))
+            else:
+                out_f.write("%s = %s\n" % (key,str(item)))
+        out_f.close()
+        Write custom configuration
+        """
+        path = get_custom_config_path()
+        with open(path, 'w') as out_f:
+            out_f.write("#Application appearance custom configuration\n")
+            for key, item in self.return_string.iteritems():
+                if (key == 'DEFAULT_PERSPECTIVE') or \
+                    (key == 'DEFAULT_OPEN_FOLDER' and item != None):
+                    out_f.write("%s = \"%s\"\n" % (key, str(item)))
+                else:
+                    out_f.write("%s = %s\n" % (key, str(item)))

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

-                      rb1c2011
+                      r12f7f24
 import py_compile
 import shutil
+from sasmodels.sasview_model import load_custom_model, load_standard_models
 # Explicitly import from the pluginmodel module so that py2exe
 # places it in the distribution. The Model1DPlugin class is used
 # as the base class of plug-in models.
+from sas.sasgui import get_user_dir
 from sas.sascalc.fit.pluginmodel import Model1DPlugin
 from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller
-from sasmodels.sasview_model import load_custom_model, load_standard_models
 logger = logging.getLogger(__name__)
 …
 PLUGIN_DIR = 'plugin_models'
+PLUGIN_LOG = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR,
+                          "plugins.log")
+PLUGIN_LOG = os.path.join(get_user_dir(), PLUGIN_DIR, "plugins.log")
 PLUGIN_NAME_BASE = '[plug-in] '

src/sas/sasgui/plottools/init.py

rd7bb526	refe730d
1		~~import config~~
2	1	from PlotPanel import PlotPanel
3	2	from plottables import Data1D, Theory1D

src/sas/sasgui/plottools/config.py

rd7bb526	ra2a1c20
38	38	import pkg_resources
39	39	pkg_resources.require("matplotlib>=" + plot_version)
40		except:
	40	except ImportError:
41	41	from distutils.version import LooseVersion as Version
42	42	if Version(matplotlib.__version__) < Version(plot_version):

SasView

Changeset 706bb4e in sasview for src/sas/sasgui

Legend:

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

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

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

src/sas/sasgui/perspectives/fitting/media/fitting_help.rst

src/sas/sasgui/perspectives/fitting/media/plugin.rst

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

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

src/sas/sasgui/plottools/plottables.py

src/sas/sasgui/init.py

src/sas/sasgui/guiframe/CategoryInstaller.py

src/sas/sasgui/guiframe/aboutbox.py

src/sas/sasgui/guiframe/acknowledgebox.py

src/sas/sasgui/guiframe/config.py

src/sas/sasgui/guiframe/customdir.py

src/sas/sasgui/guiframe/data_panel.py

src/sas/sasgui/guiframe/documentation_window.py

src/sas/sasgui/guiframe/gui_manager.py

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

src/sas/sasgui/guiframe/startup_configuration.py

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

src/sas/sasgui/plottools/init.py

src/sas/sasgui/plottools/config.py

Download in other formats: