Changeset 277257f in sasview


Ignore:
Timestamp:
Jul 5, 2017 5:28:55 PM (7 years ago)
Author:
Paul Kienzle <pkienzle@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
1386b2f
Parents:
251ef684
Message:

clean up plugin-model handling code; preserve active parameter values when plugin is updated

Location:
src/sas
Files:
7 edited
1 moved

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/fit/models.py

    r65f3930 r277257f  
    1616 
    1717from sasmodels.sasview_model import load_custom_model, load_standard_models 
     18from sasmodels.sasview_model import MultiplicationModel 
    1819 
    1920# Explicitly import from the pluginmodel module so that py2exe 
    … …  
    2122# as the base class of plug-in models. 
    2223from .pluginmodel import Model1DPlugin 
    23  
    24 from sas.sasgui.guiframe.CategoryInstaller import CategoryInstaller 
    2524 
    2625logger = logging.getLogger(__name__) 
    … …  
    9291    The plugin directory is located in the user's home directory. 
    9392    """ 
    94     dir = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR) 
    95  
     93    path = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR) 
     94 
     95    # TODO: initializing ~/.sasview/plugin_models doesn't belong in sascalc 
    9696    # If the plugin directory doesn't exist, create it 
    97     if not os.path.isdir(dir): 
    98         os.makedirs(dir) 
    99  
    100     # Find paths needed 
    101     # TODO: remove unneeded try/except block 
    102     try: 
    103         # For source 
    104         if os.path.isdir(os.path.dirname(__file__)): 
    105             p_dir = os.path.join(os.path.dirname(__file__), PLUGIN_DIR) 
    106         else: 
    107             raise 
    108     except Exception: 
    109         # Check for data path next to exe/zip file. 
    110         #Look for maximum n_dir up of the current dir to find plugins dir 
    111         n_dir = 12 
    112         p_dir = None 
    113         f_dir = os.path.join(os.path.dirname(__file__)) 
    114         for i in range(n_dir): 
    115             if i > 1: 
    116                 f_dir, _ = os.path.split(f_dir) 
    117             plugin_path = os.path.join(f_dir, PLUGIN_DIR) 
    118             if os.path.isdir(plugin_path): 
    119                 p_dir = plugin_path 
    120                 break 
    121         if not p_dir: 
    122             raise 
    123     # Place example user models as needed 
    124     if os.path.isdir(p_dir): 
    125         for file in os.listdir(p_dir): 
    126             file_path = os.path.join(p_dir, file) 
    127             if os.path.isfile(file_path): 
    128                 if file.split(".")[-1] == 'py' and\ 
    129                     file.split(".")[0] != '__init__': 
    130                     if not os.path.isfile(os.path.join(dir, file)): 
    131                         shutil.copy(file_path, dir) 
    132  
    133     return dir 
    134  
    135  
    136 class ReportProblem: 
     97    if not os.path.isdir(path): 
     98        os.makedirs(path) 
     99    # TODO: should we be checking for new default models every time? 
     100    initialize_plugins_dir(path) 
     101    return path 
     102 
     103 
     104def initialize_plugins_dir(path): 
     105    # TODO: There are no default plugins 
     106    # TODO: Move default plugins beside sample data files 
     107    # TODO: Should not look for defaults above the root of the sasview install 
     108 
     109    # Walk up the tree looking for default plugin_models directory 
     110    base = os.path.abspath(os.path.dirname(__file__)) 
     111    for _ in range(12): 
     112        default_plugins_path = os.path.join(base, PLUGIN_DIR) 
     113        if os.path.isdir(default_plugins_path): 
     114            break 
     115        base, _ = os.path.split(base) 
     116    else: 
     117        logger.error("default plugins directory not found") 
     118        return 
     119 
     120    # Copy files from default plugins to the .sasview directory 
     121    # This may include c files, depending on the example. 
     122    # Note: files are never replaced, even if the default plugins are updated 
     123    for filename in os.listdir(default_plugins_path): 
     124        # skip __init__.py and all pyc files 
     125        if filename == "__init__.py" or filename.endswith('.pyc'): 
     126            continue 
     127        source = os.path.join(default_plugins_path, filename) 
     128        target = os.path.join(path, filename) 
     129        if os.path.isfile(source) and not os.path.isfile(target): 
     130            shutil.copy(source, target) 
     131 
     132 
     133class ReportProblem(object): 
    137134    """ 
    138135    Class to check for problems with specific values 
    … …  
    161158 
    162159 
    163 def _find_models(): 
     160def find_plugin_models(): 
    164161    """ 
    165162    Find custom models 
    166163    """ 
    167164    # List of plugin objects 
    168     directory = find_plugins_dir() 
     165    plugins_dir = find_plugins_dir() 
    169166    # Go through files in plug-in directory 
    170     if not os.path.isdir(directory): 
    171         msg = "SasView couldn't locate Model plugin folder %r." % directory 
     167    if not os.path.isdir(plugins_dir): 
     168        msg = "SasView couldn't locate Model plugin folder %r." % plugins_dir 
    172169        logger.warning(msg) 
    173170        return {} 
    174171 
    175     plugin_log("looking for models in: %s" % str(directory)) 
    176     # compile_file(directory)  #always recompile the folder plugin 
    177     logger.info("plugin model dir: %s", str(directory)) 
     172    plugin_log("looking for models in: %s" % plugins_dir) 
     173    # compile_file(plugins_dir)  #always recompile the folder plugin 
     174    logger.info("plugin model dir: %s", plugins_dir) 
    178175 
    179176    plugins = {} 
    180     for filename in os.listdir(directory): 
     177    for filename in os.listdir(plugins_dir): 
    181178        name, ext = os.path.splitext(filename) 
    182179        if ext == '.py' and not name == '__init__': 
    183             path = os.path.abspath(os.path.join(directory, filename)) 
     180            path = os.path.abspath(os.path.join(plugins_dir, filename)) 
    184181            try: 
    185182                model = load_custom_model(path) 
    186                 model.name = PLUGIN_NAME_BASE + model.name 
     183                # TODO: add [plug-in] tag to model name in sasview_model 
     184                if not model.name.startswith(PLUGIN_NAME_BASE): 
     185                    model.name = PLUGIN_NAME_BASE + model.name 
    187186                plugins[model.name] = model 
    188187            except Exception: 
    … …  
    196195 
    197196 
    198 class ModelList(object): 
    199     """ 
    200     Contains dictionary of model and their type 
    201     """ 
     197class ModelManagerBase(object): 
     198    """ 
     199    Base class for the model manager 
     200    """ 
     201    #: mutable dictionary of models, continually updated to reflect the 
     202    #: current set of plugins 
     203    model_dictionary = None  # type: Dict[str, Model] 
     204    #: constant list of standard models 
     205    standard_models = None  # type: Dict[str, Model] 
     206    #: list of plugin models reset each time the plugin directory is queried 
     207    plugin_models = None  # type: Dict[str, Model] 
     208    #: timestamp on the plugin directory at the last plugin update 
     209    last_time_dir_modified = 0  # type: int 
     210 
    202211    def __init__(self): 
    203         """ 
    204         """ 
    205         self.mydict = {} 
    206  
    207     def set_list(self, name, mylist): 
    208         """ 
    209         :param name: the type of the list 
    210         :param mylist: the list to add 
    211  
    212         """ 
    213         if name not in self.mydict.keys(): 
    214             self.reset_list(name, mylist) 
    215  
    216     def reset_list(self, name, mylist): 
    217         """ 
    218         :param name: the type of the list 
    219         :param mylist: the list to add 
    220         """ 
    221         self.mydict[name] = mylist 
    222  
    223     def get_list(self): 
    224         """ 
    225         return all the list stored in a dictionary object 
    226         """ 
    227         return self.mydict 
    228  
    229  
    230 class ModelManagerBase(object): 
    231     """ 
    232     Base class for the model manager 
    233     """ 
    234     ## external dict for models 
    235     model_combobox = ModelList() 
    236     ## Dictionary of form factor models 
    237     form_factor_dict = {} 
    238     ## dictionary of structure factor models 
    239     struct_factor_dict = {} 
    240     ##list of structure factors 
    241     struct_list = [] 
    242     ##list of model allowing multiplication by a structure factor 
    243     multiplication_factor = [] 
    244     ##list of multifunctional shapes (i.e. that have user defined number of levels 
    245     multi_func_list = [] 
    246     ## list of added models -- currently python models found in the plugin dir. 
    247     plugins = [] 
    248     ## Event owner (guiframe) 
    249     event_owner = None 
    250     last_time_dir_modified = 0 
    251  
    252     def __init__(self): 
     212        # the model dictionary is allocated at the start and updated to 
     213        # reflect the current list of models.  Be sure to clear it rather 
     214        # than reassign to it. 
    253215        self.model_dictionary = {} 
    254         self.stored_plugins = {} 
    255         self._getModelList() 
    256  
    257     def findModels(self): 
    258         """ 
    259         find  plugin model in directory of plugin .recompile all file 
    260         in the directory if file were modified 
    261         """ 
    262         temp = {} 
    263         if self.is_changed(): 
    264             return  _find_models() 
    265         logger.info("plugin model : %s", str(temp)) 
    266         return temp 
    267  
    268     def _getModelList(self): 
    269         """ 
    270         List of models we want to make available by default 
    271         for this application 
    272  
    273         :return: the next free event ID following the new menu events 
    274  
    275         """ 
    276  
    277         # regular model names only 
    278         self.model_name_list = [] 
    279216 
    280217        #Build list automagically from sasmodels package 
    281         for model in load_standard_models(): 
    282             self.model_dictionary[model.name] = model 
    283             if model.is_structure_factor: 
    284                 self.struct_list.append(model) 
    285             if model.is_form_factor: 
    286                 self.multiplication_factor.append(model) 
    287             if model.is_multiplicity_model: 
    288                 self.multi_func_list.append(model) 
    289             else: 
    290                 self.model_name_list.append(model.name) 
    291  
    292         #Looking for plugins 
    293         self.stored_plugins = self.findModels() 
    294         self.plugins = self.stored_plugins.values() 
    295         for name, plug in self.stored_plugins.iteritems(): 
    296             self.model_dictionary[name] = plug 
    297  
    298         self._get_multifunc_models() 
    299  
    300         return 0 
    301  
    302     def is_changed(self): 
     218        self.standard_models = {model.name: model 
     219                                for model in load_standard_models()} 
     220        # Look for plugins 
     221        self.plugins_reset() 
     222 
     223    def _is_plugin_dir_changed(self): 
    303224        """ 
    304225        check the last time the plugin dir has changed and return true 
    … …  
    308229        plugin_dir = find_plugins_dir() 
    309230        if os.path.isdir(plugin_dir): 
    310             temp = os.path.getmtime(plugin_dir) 
    311             if  self.last_time_dir_modified != temp: 
     231            mod_time = os.path.getmtime(plugin_dir) 
     232            if  self.last_time_dir_modified != mod_time: 
    312233                is_modified = True 
    313                 self.last_time_dir_modified = temp 
     234                self.last_time_dir_modified = mod_time 
    314235 
    315236        return is_modified 
    316237 
    317     def update(self): 
     238    def composable_models(self): 
     239        """ 
     240        return list of standard models that can be used in sum/multiply 
     241        """ 
     242        # TODO: should scan plugin models in addition to standard models 
     243        # and update model_editor so that it doesn't add plugins to the list 
     244        return [model.name for model in self.standard_models.values() 
     245                if not model.is_multiplicity_model] 
     246 
     247    def plugins_update(self): 
    318248        """ 
    319249        return a dictionary of model if 
    320250        new models were added else return empty dictionary 
    321251        """ 
    322         new_plugins = self.findModels() 
    323         if len(new_plugins) > 0: 
    324             for name, plug in  new_plugins.iteritems(): 
    325                 if name not in self.stored_plugins.keys(): 
    326                     self.stored_plugins[name] = plug 
    327                     self.plugins.append(plug) 
    328                     self.model_dictionary[name] = plug 
    329             self.model_combobox.set_list("Plugin Models", self.plugins) 
    330             return self.model_combobox.get_list() 
    331         else: 
    332             return {} 
     252        return self.plugins_reset() 
     253        #if self._is_plugin_dir_changed(): 
     254        #    return self.plugins_reset() 
     255        #else: 
     256        #    return {} 
    333257 
    334258    def plugins_reset(self): 
    … …  
    336260        return a dictionary of model 
    337261        """ 
    338         self.plugins = [] 
    339         new_plugins = _find_models() 
    340         for name, plug in  new_plugins.iteritems(): 
    341             for stored_name, stored_plug in self.stored_plugins.iteritems(): 
    342                 if name == stored_name: 
    343                     del self.stored_plugins[name] 
    344                     del self.model_dictionary[name] 
    345                     break 
    346             self.stored_plugins[name] = plug 
    347             self.plugins.append(plug) 
    348             self.model_dictionary[name] = plug 
    349  
    350         self.model_combobox.reset_list("Plugin Models", self.plugins) 
    351         return self.model_combobox.get_list() 
    352  
    353     def _on_model(self, evt): 
    354         """ 
    355         React to a model menu event 
    356  
    357         :param event: wx menu event 
    358  
    359         """ 
    360         if int(evt.GetId()) in self.form_factor_dict.keys(): 
    361             from sasmodels.sasview_model import MultiplicationModel 
    362             self.model_dictionary[MultiplicationModel.__name__] = MultiplicationModel 
    363             model1, model2 = self.form_factor_dict[int(evt.GetId())] 
    364             model = MultiplicationModel(model1, model2) 
    365         else: 
    366             model = self.struct_factor_dict[str(evt.GetId())]() 
    367  
    368  
    369     def _get_multifunc_models(self): 
    370         """ 
    371         Get the multifunctional models 
    372         """ 
    373         items = [item for item in self.plugins if item.is_multiplicity_model] 
    374         self.multi_func_list = items 
     262        self.plugin_models = find_plugin_models() 
     263        self.model_dictionary.clear() 
     264        self.model_dictionary.update(self.standard_models) 
     265        self.model_dictionary.update(self.plugin_models) 
     266        return self.get_model_list() 
    375267 
    376268    def get_model_list(self): 
    377269        """ 
    378         return dictionary of models for fitpanel use 
    379  
     270        return dictionary of classified models 
     271 
     272        *Structure Factors* are the structure factor models 
     273        *Multi-Functions* are the multiplicity models 
     274        *Plugin Models* are the plugin models 
     275 
     276        Note that a model can be both a plugin and a structure factor or 
     277        multiplicity model. 
    380278        """ 
    381279        ## Model_list now only contains attribute lists not category list. 
    … …  
    387285        ## -PDB   April 26, 2014 
    388286 
    389 #        self.model_combobox.set_list("Shapes", self.shape_list) 
    390 #        self.model_combobox.set_list("Shape-Independent", 
    391 #                                     self.shape_indep_list) 
    392         self.model_combobox.set_list("Structure Factors", self.struct_list) 
    393         self.model_combobox.set_list("Plugin Models", self.plugins) 
    394         self.model_combobox.set_list("P(Q)*S(Q)", self.multiplication_factor) 
    395         self.model_combobox.set_list("multiplication", 
    396                                      self.multiplication_factor) 
    397         self.model_combobox.set_list("Multi-Functions", self.multi_func_list) 
    398         return self.model_combobox.get_list() 
    399  
    400     def get_model_name_list(self): 
    401         """ 
    402         return regular model name list 
    403         """ 
    404         return self.model_name_list 
    405  
    406     def get_model_dictionary(self): 
    407         """ 
    408         return dictionary linking model names to objects 
    409         """ 
    410         return self.model_dictionary 
     287 
     288        # Classify models 
     289        structure_factors = [] 
     290        multiplicity_models = [] 
     291        for model in self.model_dictionary.values(): 
     292            # Old style models don't have is_structure_factor attribute 
     293            if getattr(model, 'is_structure_factor', False): 
     294                structure_factors.append(model) 
     295            if model.is_multiplicity_model: 
     296                multiplicity_models.append(model) 
     297        plugin_models = list(self.plugin_models.values()) 
     298 
     299        return { 
     300            "Structure Factors": structure_factors, 
     301            "Plugin Models": plugin_models, 
     302            "Multi-Functions": multiplicity_models, 
     303        } 
    411304 
    412305 
    413306class ModelManager(object): 
    414307    """ 
    415     implement model 
     308    manage the list of available models 
    416309    """ 
    417310    base = None  # type: ModelManagerBase() 
    … …  
    419312    def __init__(self): 
    420313        if ModelManager.base is None: 
    421             self.base = ModelManagerBase() 
     314            ModelManager.base = ModelManagerBase() 
    422315 
    423316    def cat_model_list(self): 
    424         models = self.base.model_dictionary 
    425         retval = [model for model_name, model in models.items() 
    426                   if model_name not in self.base.stored_plugins] 
    427         return retval 
    428  
    429     def findModels(self): 
    430         return self.base.findModels() 
    431  
    432     def _getModelList(self): 
    433         return self.base._getModelList() 
    434  
    435     def is_changed(self): 
    436         return self.base.is_changed() 
     317        return list(self.base.standard_models.values()) 
    437318 
    438319    def update(self): 
    439         return self.base.update() 
     320        return self.base.plugins_update() 
    440321 
    441322    def plugins_reset(self): 
    442323        return self.base.plugins_reset() 
    443324 
    444     #def populate_menu(self, modelmenu, event_owner): 
    445     #    return self.base.populate_menu(modelmenu, event_owner) 
    446  
    447     def _on_model(self, evt): 
    448         return self.base._on_model(evt) 
    449  
    450     def _get_multifunc_models(self): 
    451         return self.base._get_multifunc_models() 
    452  
    453325    def get_model_list(self): 
    454326        return self.base.get_model_list() 
    455327 
    456     def get_model_name_list(self): 
    457         return self.base.get_model_name_list() 
     328    def composable_models(self): 
     329        return self.base.composable_models() 
    458330 
    459331    def get_model_dictionary(self): 
    460         return self.base.get_model_dictionary() 
     332        return self.base.model_dictionary 

  • src/sas/sascalc/fit/pagestate.py

    rba8d326 r277257f  
    225225        # contains link between a model and selected parameters to fit 
    226226        self.param_toFit = [] 
    227         # dictionary of model type and model class 
    228         self.model_list_box = None 
    229227        # save the state of the context menu 
    230228        self.saved_states = {} 
    … …  
    288286        obj.data_name = self.data_name 
    289287        obj.is_data = self.is_data 
    290         obj.model_list_box = copy.deepcopy(self.model_list_box) 
    291288 
    292289        obj.categorycombobox = self.categorycombobox 
    … …  
    967964            # Get file name 
    968965            entry = get_content('ns:filename', node) 
    969             if entry is not None: 
     966            if entry is not None and entry.text: 
    970967                self.file = entry.text.strip() 
     968            else: 
     969                self.file = '' 
    971970 
    972971            # Get time stamp 

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

    r65f3930 r277257f  
    3131import re 
    3232import logging 
     33import datetime 
     34 
    3335from wx.py.editwindow import EditWindow 
     36 
    3437from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     38 
    3539from .pyconsole import show_model_output, check_model 
    3640 
    3741logger = logging.getLogger(__name__) 
    38  
    3942 
    4043if sys.platform.count("win32") > 0: 
    … …  
    7881    a Modal Dialog. 
    7982 
    80     :TODO the build in compiler currently balks at when it tries to import 
     83    :TODO the built in compiler currently balks at when it tries to import 
    8184    a model whose name contains spaces or symbols (such as + ... underscore 
    8285    should be fine).  Have fixed so the editor cannot save such a file name 
    … …  
    336339            list_fnames = os.listdir(self.plugin_dir) 
    337340            # fake existing regular model name list 
    338             m_list = [model + ".py" for model in self.model_list] 
     341            m_list = [model.name + ".py" for model in self.model_list] 
    339342            list_fnames.append(m_list) 
    340343            if t_fname in list_fnames and title != mname: 
    … …  
    855858                    exec "float(math.%s)" % item 
    856859                    self.math_combo.Append(str(item)) 
    857                 except: 
     860                except Exception: 
    858861                    self.math_combo.Append(str(item) + "()") 
    859862        self.math_combo.Bind(wx.EVT_COMBOBOX, self._on_math_select) 
    … …  
    980983            msg = "Name exists already." 
    981984 
    982         # Prepare the messagebox 
     985        # 
    983986        if self.base is not None and not msg: 
    984987            self.base.update_custom_combo() 
    985             # Passed exception in import test as it will fail for sasmodels.sasview_model class 
    986             # Should add similar test for new style? 
    987             Model = None 
    988             try: 
    989                 exec "from %s import Model" % name 
    990             except: 
    991                 logger.error(sys.exc_value) 
    992988 
    993989        # Prepare the messagebox 
    … …  
    10201016        :param func_str: content of func; Strings 
    10211017        """ 
    1022         try: 
    1023             out_f = open(fname, 'w') 
    1024         except: 
    1025             raise 
    1026         # Prepare the content of the function 
    1027         lines = CUSTOM_TEMPLATE.split('\n') 
    1028  
    1029         has_scipy = func_str.count("scipy.") 
    1030         if has_scipy: 
    1031             lines.insert(0, 'import scipy') 
    1032  
    1033         # Think about 2D later 
    1034         #self.is_2d = func_str.count("#self.ndim = 2") 
    1035         #line_2d = '' 
    1036         #if self.is_2d: 
    1037         #    line_2d = CUSTOM_2D_TEMP.split('\n') 
    1038  
    1039         # Also think about test later 
    1040         #line_test = TEST_TEMPLATE.split('\n') 
    1041         #local_params = '' 
    1042         #spaces = '        '#8spaces 
    1043         spaces4  = ' '*4 
    1044         spaces13 = ' '*13 
    1045         spaces16 = ' '*16 
     1018        out_f = open(fname, 'w') 
     1019 
     1020        out_f.write(CUSTOM_TEMPLATE % { 
     1021            'name': name, 
     1022            'title': 'User model for ' + name, 
     1023            'description': desc_str, 
     1024            'date': datetime.datetime.now().strftime('%YYYY-%mm-%dd'), 
     1025        }) 
     1026 
     1027        # Write out parameters 
    10461028        param_names = []    # to store parameter names 
    1047         has_scipy = func_str.count("scipy.") 
    1048         if has_scipy: 
    1049             lines.insert(0, 'import scipy') 
    1050  
    1051         # write function here 
    1052         for line in lines: 
    1053             # The location where to put the strings is 
    1054             # hard-coded in the template as shown below. 
    1055             out_f.write(line + '\n') 
    1056             if line.count('#name'): 
    1057                 out_f.write('name = "%s" \n' % name) 
    1058             elif line.count('#title'): 
    1059                 out_f.write('title = "User model for %s"\n' % name) 
    1060             elif line.count('#description'): 
    1061                 out_f.write('description = "%s"\n' % desc_str) 
    1062             elif line.count('#parameters'): 
    1063                 out_f.write('parameters = [ \n') 
    1064                 for param_line in param_str.split('\n'): 
    1065                     p_line = param_line.lstrip().rstrip() 
    1066                     if p_line: 
    1067                         pname, pvalue = self.get_param_helper(p_line) 
    1068                         param_names.append(pname) 
    1069                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', ''],\n" % (spaces16, pname, pvalue)) 
    1070                 for param_line in pd_param_str.split('\n'): 
    1071                     p_line = param_line.lstrip().rstrip() 
    1072                     if p_line: 
    1073                         pname, pvalue = self.get_param_helper(p_line) 
    1074                         param_names.append(pname) 
    1075                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', ''],\n" % (spaces16, pname, pvalue)) 
    1076                 out_f.write('%s]\n' % spaces13) 
    1077  
    1078         # No form_volume or ER available in simple model editor 
    1079         out_f.write('def form_volume(*arg): \n') 
    1080         out_f.write('    return 1.0 \n') 
    1081         out_f.write('\n') 
    1082         out_f.write('def ER(*arg): \n') 
    1083         out_f.write('    return 1.0 \n') 
    1084  
    1085         # function to compute 
    1086         out_f.write('\n') 
    1087         out_f.write('def Iq(x ') 
    1088         for name in param_names: 
    1089             out_f.write(', %s' % name) 
    1090         out_f.write('):\n') 
     1029        pd_params = [] 
     1030        out_f.write('parameters = [ \n') 
     1031        out_f.write('#   ["name", "units", default, [lower, upper], "type", "description"],\n') 
     1032        for pname, pvalue in self.get_param_helper(param_str): 
     1033            param_names.append(pname) 
     1034            out_f.write("    ['%s', '', %s, [-inf, inf], '', ''],\n" 
     1035                        % (pname, pvalue)) 
     1036        for pname, pvalue in self.get_param_helper(pd_param_str): 
     1037            param_names.append(pname) 
     1038            pd_params.append(pname) 
     1039            out_f.write("    ['%s', '', %s, [-inf, inf], 'volume', ''],\n" 
     1040                        % (pname, pvalue)) 
     1041        out_f.write('    ]\n') 
     1042 
     1043        # Write out function definition 
     1044        out_f.write('def Iq(%s):\n' % ', '.join(['x'] + param_names)) 
     1045        out_f.write('    """Absolute scattering"""\n') 
     1046        if "scipy." in func_str: 
     1047            out_f.write('    import scipy') 
     1048        if "numpy." in func_str: 
     1049            out_f.write('    import numpy') 
     1050        if "np." in func_str: 
     1051            out_f.write('    import numpy as np') 
    10911052        for func_line in func_str.split('\n'): 
    10921053            out_f.write('%s%s\n' % (spaces4, func_line)) 
    1093  
    1094         Iqxy_string = 'return Iq(numpy.sqrt(x**2+y**2) ' 
    1095  
     1054        out_f.write('## uncomment the following if Iq works for vector x\n') 
     1055        out_f.write('#Iq.vectorized = True\n') 
     1056 
     1057        # If polydisperse, create place holders for form_volume, ER and VR 
     1058        if pd_params: 
     1059            out_f.write('\n') 
     1060            out_f.write(CUSTOM_TEMPLATE_PD % {'args': ', '.join(pd_params)}) 
     1061 
     1062        # Create place holder for Iqxy 
    10961063        out_f.write('\n') 
    1097         out_f.write('def Iqxy(x, y ') 
    1098         for name in param_names: 
    1099             out_f.write(', %s' % name) 
    1100             Iqxy_string += ', ' + name 
    1101         out_f.write('):\n') 
    1102         Iqxy_string += ')' 
    1103         out_f.write('%s%s\n' % (spaces4, Iqxy_string)) 
     1064        out_f.write('#def Iqxy(%s):\n' % ', '.join(["x", "y"] + param_names)) 
     1065        out_f.write('#    """Absolute scattering of oriented particles."""\n') 
     1066        out_f.write('#    ...\n') 
     1067        out_f.write('#    return oriented_form(x, y, args)\n') 
     1068        out_f.write('## uncomment the following if Iqxy works for vector x, y\n') 
     1069        out_f.write('#Iqxy.vectorized = True\n') 
    11041070 
    11051071        out_f.close() 
    11061072 
    1107     def get_param_helper(self, line): 
    1108         """ 
    1109         Get string in line to define the params dictionary 
    1110  
    1111         :param line: one line of string got from the param_str 
    1112         """ 
    1113         items = line.split(";") 
    1114         for item in items: 
    1115             name = item.split("=")[0].lstrip().rstrip() 
    1116             try: 
    1117                 value = item.split("=")[1].lstrip().rstrip() 
    1118                 float(value) 
    1119             except: 
    1120                 value = 1.0 # default 
    1121  
    1122         return name, value 
     1073    def get_param_helper(self, param_str): 
     1074        """ 
     1075        yield a sequence of name, value pairs for the parameters in param_str 
     1076 
     1077        Parameters can be defined by one per line by name=value, or multiple 
     1078        on the same line by separating the pairs by semicolon or comma.  The 
     1079        value is optional and defaults to "1.0". 
     1080        """ 
     1081        for line in param_str.replace(';', ',').split('\n'): 
     1082            for item in line.split(','): 
     1083                parts = item.plit('=') 
     1084                name = parts[0].strip() 
     1085                value = parts[1] if len(parts) > 0 else '1.0' 
     1086                if name: 
     1087                    yield name, value 
    11231088 
    11241089    def set_function_helper(self, line): 
    … …  
    11541119        running "file:///...." 
    11551120 
    1156     :param evt: Triggers on clicking the help button 
    1157     """ 
     1121        :param evt: Triggers on clicking the help button 
     1122        """ 
    11581123 
    11591124        _TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html" 
    … …  
    11981163## Templates for plugin models 
    11991164 
    1200 CUSTOM_TEMPLATE = """ 
     1165CUSTOM_TEMPLATE = '''\ 
     1166r""" 
     1167Definition 
     1168---------- 
     1169 
     1170Calculates %(name)s. 
     1171 
     1172%(description)s 
     1173 
     1174References 
     1175---------- 
     1176 
     1177Authorship and Verification 
     1178--------------------------- 
     1179 
     1180* **Author:** --- **Date:** %(date)s 
     1181* **Last Modified by:** --- **Date:** %(date)s 
     1182* **Last Reviewed by:** --- **Date:** %(date)s 
     1183""" 
     1184 
    12011185from math import * 
    1202 import os 
    1203 import sys 
    1204 import numpy 
    1205  
    1206 #name 
    1207  
    1208 #title 
    1209  
    1210 #description 
    1211  
    1212 #parameters 
    1213  
    1214 """ 
    1215  
    1216 CUSTOM_2D_TEMP = """ 
    1217     def run(self, x=0.0, y=0.0): 
    1218         if x.__class__.__name__ == 'list': 
    1219             x_val = x[0] 
    1220             y_val = y[0]*0.0 
    1221             return self.function(x_val, y_val) 
    1222         elif x.__class__.__name__ == 'tuple': 
    1223             msg = "Tuples are not allowed as input to BaseComponent models" 
    1224             raise ValueError, msg 
    1225         else: 
    1226             return self.function(x, 0.0) 
    1227     def runXY(self, x=0.0, y=0.0): 
    1228         if x.__class__.__name__ == 'list': 
    1229             return self.function(x, y) 
    1230         elif x.__class__.__name__ == 'tuple': 
    1231             msg = "Tuples are not allowed as input to BaseComponent models" 
    1232             raise ValueError, msg 
    1233         else: 
    1234             return self.function(x, y) 
    1235     def evalDistribution(self, qdist): 
    1236         if qdist.__class__.__name__ == 'list': 
    1237             msg = "evalDistribution expects a list of 2 ndarrays" 
    1238             if len(qdist)!=2: 
    1239                 raise RuntimeError, msg 
    1240             if qdist[0].__class__.__name__ != 'ndarray': 
    1241                 raise RuntimeError, msg 
    1242             if qdist[1].__class__.__name__ != 'ndarray': 
    1243                 raise RuntimeError, msg 
    1244             v_model = numpy.vectorize(self.runXY, otypes=[float]) 
    1245             iq_array = v_model(qdist[0], qdist[1]) 
    1246             return iq_array 
    1247         elif qdist.__class__.__name__ == 'ndarray': 
    1248             v_model = numpy.vectorize(self.runXY, otypes=[float]) 
    1249             iq_array = v_model(qdist) 
    1250             return iq_array 
    1251 """ 
    1252 TEST_TEMPLATE = """ 
    1253 ###################################################################### 
    1254 ## THIS IS FOR TEST. DO NOT MODIFY THE FOLLOWING LINES!!!!!!!!!!!!!!!! 
    1255 if __name__ == "__main__": 
    1256     m= Model() 
    1257     out1 = m.runXY(0.0) 
    1258     out2 = m.runXY(0.01) 
    1259     isfine1 = numpy.isfinite(out1) 
    1260     isfine2 = numpy.isfinite(out2) 
    1261     print "Testing the value at Q = 0.0:" 
    1262     print out1, " : finite? ", isfine1 
    1263     print "Testing the value at Q = 0.01:" 
    1264     print out2, " : finite? ", isfine2 
    1265     if isfine1 and isfine2: 
    1266         print "===> Simple Test: Passed!" 
    1267     else: 
    1268         print "===> Simple Test: Failed!" 
    1269 """ 
     1186from numpy import inf 
     1187 
     1188name = "%(name)s" 
     1189title = "%(title)s" 
     1190description = """%(description)s""" 
     1191 
     1192''' 
     1193 
     1194CUSTOM_TEMPLATE_PD = '''\ 
     1195def form_volume(%(args)s): 
     1196    """ 
     1197    Volume of the particles used to compute absolute scattering intensity 
     1198    and to weight polydisperse parameter contributions. 
     1199    """ 
     1200    return 0.0 
     1201 
     1202def ER(%(args)s): 
     1203    """ 
     1204    Effective radius of particles to be used when computing structure factors. 
     1205 
     1206    Input parameters are vectors ranging over the mesh of polydispersity values. 
     1207    """ 
     1208    return 0.0 
     1209 
     1210def VR(%(args)s): 
     1211    """ 
     1212    Volume ratio of particles to be used when computing structure factors. 
     1213 
     1214    Input parameters are vectors ranging over the mesh of polydispersity values. 
     1215    """ 
     1216    return 1.0 
     1217''' 
     1218 
    12701219SUM_TEMPLATE = """ 
    12711220# A sample of an experimental model function for Sum/Multiply(Pmodel1,Pmodel2) 
    … …  
    15921541    main_app = wx.App() 
    15931542    main_frame = TextDialog(id=1, model_list=["SphereModel", "CylinderModel"], 
    1594                        plugin_dir='../fitting/plugin_models') 
     1543                            plugin_dir='../fitting/plugin_models') 
    15951544    main_frame.ShowModal() 
    15961545    main_app.MainLoop() 

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

    r65f3930 r277257f  
    504504        self.state.manager = manager 
    505505 
    506     def populate_box(self, model_dict): 
     506    def populate_box(self, model_list_box): 
    507507        """ 
    508508        Store list of model 
    509509 
    510         :param model_dict: dictionary containing list of models 
    511  
    512         """ 
    513         self.model_list_box = model_dict 
    514         self.state.model_list_box = self.model_list_box 
     510        :param model_list_box: dictionary containing categorized models 
     511        """ 
     512        self.model_list_box = model_list_box 
    515513        self.initialize_combox() 
    516514 
    517     def set_model_dictionary(self, model_dict): 
     515    def set_model_dictionary(self, model_dictionary): 
    518516        """ 
    519517        Store a dictionary linking model name -> model object 
    520518 
    521         :param model_dict: dictionary containing list of models 
    522         """ 
    523         self.model_dict = model_dict 
     519        :param model_dictionary: dictionary containing all models 
     520        """ 
     521        self.model_dictionary = model_dictionary 
    524522 
    525523    def initialize_combox(self): 
    … …  
    527525        put default value in the combo box 
    528526        """ 
    529         if self.model_list_box is not None and len(self.model_list_box) > 0: 
     527        if self.model_list_box: 
    530528            self._populate_box(self.structurebox, 
    531529                               self.model_list_box["Structure Factors"]) 
    … …  
    12181216        self.categorybox.Select(category_pos) 
    12191217        self._show_combox(None) 
    1220         if self.categorybox.GetValue() == CUSTOM_MODEL \ 
    1221                 and PLUGIN_NAME_BASE not in state.formfactorcombobox: 
     1218        if (self.categorybox.GetValue() == CUSTOM_MODEL 
     1219                and PLUGIN_NAME_BASE not in state.formfactorcombobox): 
    12221220            state.formfactorcombobox = \ 
    12231221                PLUGIN_NAME_BASE + state.formfactorcombobox 
    12241222        formfactor_pos = 0 
    12251223        for ind_form in range(self.formfactorbox.GetCount()): 
    1226             if self.formfactorbox.GetString(ind_form) == \ 
    1227                                                 (state.formfactorcombobox): 
     1224            if (self.formfactorbox.GetString(ind_form) 
     1225                    == state.formfactorcombobox): 
    12281226                formfactor_pos = int(ind_form) 
    12291227                break 
    … …  
    12351233            state.structurecombobox = unicode(state.structurecombobox) 
    12361234            for ind_struct in range(self.structurebox.GetCount()): 
    1237                 if self.structurebox.GetString(ind_struct) == \ 
    1238                                                 (state.structurecombobox): 
     1235                if (self.structurebox.GetString(ind_struct) 
     1236                        == state.structurecombobox): 
    12391237                    structfactor_pos = int(ind_struct) 
    12401238                    break 
    … …  
    18401838            if mod_cat == CUSTOM_MODEL: 
    18411839                for model in self.model_list_box[mod_cat]: 
    1842                     m_list.append(self.model_dict[model.name]) 
     1840                    m_list.append(self.model_dictionary[model.name]) 
    18431841            else: 
    18441842                cat_dic = self.master_category_dict[mod_cat] 
    1845                 for (model, enabled) in cat_dic: 
     1843                for model, enabled in cat_dic: 
    18461844                    if enabled: 
    1847                         m_list.append(self.model_dict[model]) 
     1845                        m_list.append(self.model_dictionary[model]) 
    18481846        except Exception: 
    18491847            msg = traceback.format_exc() 
    … …  
    34973495        self.model_box.Clear() 
    34983496 
    3499         if category == 'Plugin Models': 
     3497        if category == CUSTOM_MODEL: 
    35003498            for model in self.model_list_box[category]: 
    35013499                str_m = str(model).split(".")[0] 

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

    r50fcb09 r277257f  
    11431143            self.model.name = "M" + str(self.index_model) 
    11441144 
    1145     def _on_select_model(self, event=None): 
     1145    def _on_select_model(self, event=None, keep_pars=False): 
    11461146        """ 
    11471147        call back for model selection 
    11481148        """ 
    11491149        self.Show(False) 
    1150         copy_flag = False 
    1151         is_poly_enabled = None 
    11521150        if event is not None: 
    1153             if (event.GetEventObject() == self.formfactorbox 
    1154                     and self.structurebox.GetLabel() != 'None')\ 
    1155                     or event.GetEventObject() == self.structurebox\ 
    1156                     or event.GetEventObject() == self.multifactorbox: 
    1157                 copy_flag = self.get_copy_params() 
    1158                 is_poly_enabled = self.enable_disp.GetValue() 
     1151            control = event.GetEventObject() 
     1152            if ((control == self.formfactorbox 
     1153                 and self.structurebox.GetLabel() != 'None') 
     1154                    or control == self.structurebox 
     1155                    or control == self.multifactorbox): 
     1156                keep_pars = True 
     1157 
     1158        if keep_pars: 
     1159            saved_pars = self.get_copy_params() 
     1160            is_poly_enabled = self.enable_disp.GetValue() 
     1161        else: 
     1162            saved_pars = None 
     1163            is_poly_enabled = None 
    11591164 
    11601165        self._on_select_model_helper() 
    … …  
    11711176        try: 
    11721177            self.set_dispers_sizer() 
    1173         except: 
     1178        except Exception: 
    11741179            pass 
    11751180        self.state.enable_disp = self.enable_disp.GetValue() 
    … …  
    12321237            self.state.model.name = self.model.name 
    12331238 
     1239        # when select a model only from guictr/button 
     1240        if is_poly_enabled is not None: 
     1241            self.enable_disp.SetValue(is_poly_enabled) 
     1242            self.disable_disp.SetValue(not is_poly_enabled) 
     1243            self._set_dipers_Param(event=None) 
     1244            self.state.enable_disp = self.enable_disp.GetValue() 
     1245            self.state.disable_disp = self.disable_disp.GetValue() 
     1246 
     1247        # Keep the previous param values 
     1248        if saved_pars: 
     1249            self.get_paste_params(saved_pars) 
     1250 
    12341251        if event is not None: 
     1252            # update list of plugins if new plugin is available 
     1253            # mod_cat = self.categorybox.GetStringSelection() 
     1254            # if mod_cat == CUSTOM_MODEL: 
     1255            #     temp = self.parent.update_model_list() 
     1256            #     if temp: 
     1257            #         self.model_list_box = temp 
     1258            #         current_val = self.formfactorbox.GetLabel() 
     1259            #         pos = self.formfactorbox.GetSelection() 
     1260            #         self._show_combox_helper() 
     1261            #         self.formfactorbox.SetStringSelection(current_val) 
     1262            #         self.formfactorbox.SetValue(current_val) 
    12351263            # post state to fit panel 
    12361264            new_event = PageInfoEvent(page=self) 
    12371265            wx.PostEvent(self.parent, new_event) 
    1238             # update list of plugins if new plugin is available 
    1239             custom_model = CUSTOM_MODEL 
    1240             mod_cat = self.categorybox.GetStringSelection() 
    1241             if mod_cat == custom_model: 
    1242                 temp = self.parent.update_model_list() 
    1243                 if temp: 
    1244                     self.model_list_box = temp 
    1245                     current_val = self.formfactorbox.GetLabel() 
    1246                     pos = self.formfactorbox.GetSelection() 
    1247                     self._show_combox_helper() 
    1248                     self.formfactorbox.SetSelection(pos) 
    1249                     self.formfactorbox.SetValue(current_val) 
    1250             # when select a model only from guictr/button 
    1251             if is_poly_enabled is not None: 
    1252                 self.enable_disp.SetValue(is_poly_enabled) 
    1253                 self.disable_disp.SetValue(not is_poly_enabled) 
    1254                 self._set_dipers_Param(event=None) 
    1255                 self.state.enable_disp = self.enable_disp.GetValue() 
    1256                 self.state.disable_disp = self.disable_disp.GetValue() 
    1257  
    1258             # Keep the previous param values 
    1259             if copy_flag: 
    1260                 self.get_paste_params(copy_flag) 
    12611266            wx.CallAfter(self._onDraw, None) 
    12621267 
    … …  
    17091714                and not self.temp_multi_functional: 
    17101715            return None 
     1716        print("_set_fun_box_list", self.model.name) 
    17111717        # Get the func name list 
    17121718        list = self.model.fun_list 
    … …  
    17161722        ind = 0 
    17171723        while(ind < len(list)): 
    1718             for key, val in list.iteritems(): 
    1719                 if (val == ind): 
     1724            for key, val in list.items(): 
     1725                if val == ind: 
    17201726                    fun_box.Append(key, val) 
    17211727                    break 

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

    r65f3930 r277257f  
    114114        """ 
    115115        temp = self.menu_mng.update() 
    116         if len(temp): 
     116        if temp: 
    117117            self.model_list_box = temp 
    118118        return temp 
    … …  
    121121        """ 
    122122        """ 
    123         temp = self.menu_mng.plugins_reset() 
    124         if len(temp): 
    125             self.model_list_box = temp 
    126         return temp 
     123        self.model_list_box = self.menu_mng.plugins_reset() 
     124        return self.model_list_box 
    127125 
    128126    def get_page_by_id(self, uid): 
    … …  
    298296        self.model_list_box = dict 
    299297 
    300     def set_model_dict(self, m_dict): 
     298    def set_model_dictionary(self, model_dictionary): 
    301299        """ 
    302300        copy a dictionary of model name -> model object 
    303301 
    304         :param m_dict: dictionary linking model name -> model object 
     302        :param model_dictionary: dictionary linking model name -> model object 
    305303        """ 
    306304 
    … …  
    356354        panel._set_save_flag(not panel.batch_on) 
    357355        panel.set_model_dictionary(self.model_dictionary) 
    358         panel.populate_box(model_dict=self.model_list_box) 
     356        panel.populate_box(model_list_box=self.model_list_box) 
    359357        panel.formfactor_combo_init() 
    360358        panel.set_manager(self._manager) 

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

    r00f7ff1 r277257f  
    3434from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit 
    3535from sas.sascalc.fit.pagestate import Reader, PageState, SimFitPageState 
     36from sas.sascalc.fit import models 
    3637 
    3738from sas.sasgui.guiframe.dataFitting import Data2D 
    … …  
    6061from .resultpanel import ResultPanel, PlotResultEvent 
    6162from .gpu_options import GpuOptions 
    62 from . import models 
    6363 
    6464logger = logging.getLogger(__name__) 
    … …  
    297297        event_id = event.GetId() 
    298298        model_manager = models.ModelManager() 
    299         model_list = model_manager.get_model_name_list() 
     299        model_list = model_manager.composable_models() 
    300300        plug_dir = models.find_plugins_dir() 
    301301        textdial = TextDialog(None, self, wx.ID_ANY, 'Easy Sum/Multi(p1, p2) Editor', 
    … …  
    337337            self.set_edit_menu_helper(self.parent, self.edit_custom_model) 
    338338            self.set_edit_menu_helper(self.parent, self.delete_custom_model) 
    339             temp = self.fit_panel.reset_pmodel_list() 
    340             if temp: 
    341                 # Set the new plugin model list for all fit pages 
    342                 for uid, page in self.fit_panel.opened_pages.iteritems(): 
    343                     if hasattr(page, "formfactorbox"): 
    344                         page.model_list_box = temp 
    345                         current_val = page.formfactorbox.GetLabel() 
    346                         #if page.plugin_rbutton.GetValue(): 
    347                         mod_cat = page.categorybox.GetStringSelection() 
    348                         if mod_cat == custom_model: 
    349                             #pos = page.formfactorbox.GetSelection() 
    350                             page._show_combox_helper() 
    351                             new_val = page.formfactorbox.GetLabel() 
    352                             if current_val != new_val and new_val != '': 
    353                                 page.formfactorbox.SetLabel(new_val) 
    354                             else: 
    355                                 page.formfactorbox.SetLabel(current_val) 
    356         except: 
     339            new_pmodel_list = self.fit_panel.reset_pmodel_list() 
     340            if not new_pmodel_list: 
     341                return 
     342            # Set the new plugin model list for all fit pages 
     343            for uid, page in self.fit_panel.opened_pages.iteritems(): 
     344                if hasattr(page, "formfactorbox"): 
     345                    page.model_list_box = new_pmodel_list 
     346                    mod_cat = page.categorybox.GetStringSelection() 
     347                    if mod_cat == custom_model: 
     348                        box = page.formfactorbox 
     349                        model_name = box.GetValue() 
     350                        model = (box.GetClientData(box.GetCurrentSelection()) 
     351                                 if model_name else None) 
     352                        page._show_combox_helper() 
     353                        new_index = box.FindString(model_name) 
     354                        new_model = (box.GetClientData(new_index) 
     355                                     if new_index >= 0 else None) 
     356                        if new_index >= 0: 
     357                            box.SetStringSelection(model_name) 
     358                        else: 
     359                            box.SetStringSelection('') 
     360                        if model and new_model != model: 
     361                            page._on_select_model(keep_pars=True) 
     362        except Exception: 
    357363            logger.error("update_custom_combo: %s", sys.exc_value) 
    358364 
    … …  
    364370        #new_model_menu = wx.Menu() 
    365371        self.edit_model_menu.Append(wx_id, 'New Plugin Model', 
    366                                    'Add a new model function') 
     372                                    'Add a new model function') 
    367373        wx.EVT_MENU(owner, wx_id, self.make_new_model) 
    368374 
    … …  
    646652                self.parent.add_data(data_list={data.id: data}) 
    647653                wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
    648                                         title=data.title)) 
     654                             title=data.title)) 
    649655                #need to be fix later make sure we are sendind guiframe.data 
    650656                #to panel 
    … …  
    657663                self.parent.add_data(data_list={data.id: data}) 
    658664                wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
    659                                         title=data.title)) 
     665                             title=data.title)) 
    660666                page = self.add_fit_page([data]) 
    661667                caption = page.window_caption 
    662668                self.store_data(uid=page.uid, data_list=page.get_data_list(), 
    663                         caption=caption) 
     669                                caption=caption) 
    664670                self.mypanels.append(page) 
    665671 
    … …  
    778784        """ 
    779785        if item.find(".") >= 0: 
    780             param_names = re.split("\.", item) 
     786            param_names = re.split(r"\.", item) 
    781787            model_name = param_names[0] 
    782788            ##Assume max len is 3; eg., M0.radius.width 
    … …  
    881887 
    882888            self.draw_model(model=model, data=data, page_id=uid, smearer=smear, 
    883                 enable1D=enable1D, enable2D=enable2D, 
    884                 qmin=qmin, qmax=qmax, weight=weight) 
     889                            enable1D=enable1D, enable2D=enable2D, 
     890                            qmin=qmin, qmax=qmax, weight=weight) 
    885891 
    886892    def draw_model(self, model, page_id, data=None, smearer=None, 
    … …  
    925931            ## draw model 2D with no initial data 
    926932            self._draw_model2D(model=model, 
    927                                 page_id=page_id, 
    928                                 data=data, 
    929                                 enable2D=enable2D, 
    930                                 smearer=smearer, 
    931                                 qmin=qmin, 
    932                                 qmax=qmax, 
    933                                 fid=fid, 
    934                                 weight=weight, 
    935                                 state=state, 
    936                                 toggle_mode_on=toggle_mode_on, 
    937                                 update_chisqr=update_chisqr, 
    938                                 source=source) 
     933                               page_id=page_id, 
     934                               data=data, 
     935                               enable2D=enable2D, 
     936                               smearer=smearer, 
     937                               qmin=qmin, 
     938                               qmax=qmax, 
     939                               fid=fid, 
     940                               weight=weight, 
     941                               state=state, 
     942                               toggle_mode_on=toggle_mode_on, 
     943                               update_chisqr=update_chisqr, 
     944                               source=source) 
    939945 
    940946    def onFit(self, uid): 
    … …  
    945951        :param uid: id related to the panel currently calling this fit function. 
    946952        """ 
    947         if uid is None: raise RuntimeError("no page to fit") # Should never happen 
     953        if uid is None: 
     954            raise RuntimeError("no page to fit") # Should never happen 
    948955 
    949956        sim_page_uid = getattr(self.sim_page, 'uid', None) 
    … …  
    979986                    page = self.fit_panel.get_page_by_id(page_id) 
    980987                    self.set_fit_weight(uid=page.uid, 
    981                                      flag=page.get_weight_flag(), 
    982                                      is2d=page._is_2D()) 
     988                                        flag=page.get_weight_flag(), 
     989                                        is2d=page._is_2D()) 
    983990                    if not page.param_toFit: 
    984991                        msg = "No fitting parameters for %s" % page.window_caption 
    … …  
    10041011                            fitter = sim_fitter 
    10051012                        self._add_problem_to_fit(fitproblem=fitproblem, 
    1006                                              pars=pars, 
    1007                                              fitter=fitter, 
    1008                                              fit_id=fit_id) 
     1013                                                 pars=pars, 
     1014                                                 fitter=fitter, 
     1015                                                 fit_id=fit_id) 
    10091016                        fit_id += 1 
    10101017                    list_page_id.append(page_id) 
    … …  
    10531060            ## Perform more than 1 fit at the time 
    10541061            calc_fit = FitThread(handler=handler, 
    1055                                     fn=fitter_list, 
    1056                                     batch_inputs=batch_inputs, 
    1057                                     batch_outputs=batch_outputs, 
    1058                                     page_id=list_page_id, 
    1059                                     updatefn=handler.update_fit, 
    1060                                     completefn=self._fit_completed) 
     1062                                 fn=fitter_list, 
     1063                                 batch_inputs=batch_inputs, 
     1064                                 batch_outputs=batch_outputs, 
     1065                                 page_id=list_page_id, 
     1066                                 updatefn=handler.update_fit, 
     1067                                 completefn=self._fit_completed) 
    10611068        #self.fit_thread_list[current_page_id] = calc_fit 
    10621069        self.fit_thread_list[uid] = calc_fit 
    … …  
    11191126                evt = StatusEvent(status=msg, info="warning") 
    11201127                wx.PostEvent(self.parent, evt) 
    1121         except: 
     1128        except Exception: 
    11221129            msg = "Creating Fit page: %s" % sys.exc_value 
    11231130            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    … …  
    11431150                    group_id = str(page.uid) + " Model1D" 
    11441151                    wx.PostEvent(self.parent, 
    1145                              NewPlotEvent(group_id=group_id, 
    1146                                                action="delete")) 
     1152                                 NewPlotEvent(group_id=group_id, 
     1153                                              action="delete")) 
    11471154                    self.parent.update_data(prev_data=theory_data, 
    1148                                              new_data=data) 
     1155                                            new_data=data) 
    11491156            else: 
    11501157                if theory_data is not None: 
    … …  
    11521159                    data.group_id = theory_data.group_id 
    11531160                    wx.PostEvent(self.parent, 
    1154                              NewPlotEvent(group_id=group_id, 
    1155                                                action="delete")) 
     1161                                 NewPlotEvent(group_id=group_id, 
     1162                                              action="delete")) 
    11561163                    self.parent.update_data(prev_data=theory_data, 
    1157                                              new_data=data) 
     1164                                            new_data=data) 
    11581165        self.store_data(uid=page.uid, data_list=page.get_data_list(), 
    11591166                        caption=page.window_caption) 
    … …  
    15571564                    except KeyboardInterrupt: 
    15581565                        fit_msg += "\nSingular point: Fitting stopped." 
    1559                     except: 
     1566                    except Exception: 
    15601567                        fit_msg += "\nSingular point: Fitting error occurred." 
    15611568                if fit_msg: 
    1562                    evt = StatusEvent(status=fit_msg, info="warning", type="stop") 
    1563                    wx.PostEvent(self.parent, evt) 
    1564  
    1565         except: 
     1569                    evt = StatusEvent(status=fit_msg, info="warning", type="stop") 
     1570                    wx.PostEvent(self.parent, evt) 
     1571 
     1572        except Exception: 
    15661573            msg = ("Fit completed but the following error occurred: %s" 
    15671574                   % sys.exc_value) 
    … …  
    17211728                                                  fid=data.id) 
    17221729        self.parent.update_theory(data_id=data.id, theory=new_plot, 
    1723                                    state=state) 
     1730                                  state=state) 
    17241731        return new_plot 
    17251732 
    … …  
    17751782 
    17761783        self.page_finder[page_id].set_theory_data(data=new_plot, 
    1777                                                       fid=data.id) 
     1784                                                  fid=data.id) 
    17781785        if toggle_mode_on: 
    17791786            wx.PostEvent(self.parent, 
    17801787                         NewPlotEvent(group_id=str(page_id) + " Model2D", 
    1781                                           action="Hide")) 
     1788                                      action="Hide")) 
    17821789        else: 
    17831790            if update_chisqr: 
    1784                 wx.PostEvent(current_pg, 
    1785                              Chi2UpdateEvent(output=self._cal_chisqr( 
    1786                                                                 data=data, 
    1787                                                                 fid=fid, 
    1788                                                                 weight=weight, 
    1789                                                                 page_id=page_id, 
    1790                                                                 index=index))) 
     1791                output = self._cal_chisqr(data=data, 
     1792                                          fid=fid, 
     1793                                          weight=weight, 
     1794                                          page_id=page_id, 
     1795                                          index=index) 
     1796                wx.PostEvent(current_pg, Chi2UpdateEvent(output=output)) 
    17911797            else: 
    17921798                self._plot_residuals(page_id=page_id, data=data, fid=fid, 
    … …  
    17961802            logger.error("Using the present parameters the model does not return any finite value. ") 
    17971803            msg = "Computing Error: Model did not return any finite value." 
    1798             wx.PostEvent(self.parent, StatusEvent(status = msg, info="error")) 
     1804            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    17991805        else: 
    18001806            msg = "Computation  completed!" 
    … …  
    18211827 
    18221828    def _complete2D(self, image, data, model, page_id, elapsed, index, qmin, 
    1823                 qmax, fid=None, weight=None, toggle_mode_on=False, state=None, 
    1824                      update_chisqr=True, source='model', plot_result=True): 
     1829                    qmax, fid=None, weight=None, toggle_mode_on=False, state=None, 
     1830                    update_chisqr=True, source='model', plot_result=True): 
    18251831        """ 
    18261832        Complete get the result of modelthread and create model 2D 
    … …  
    18631869                                                  fid=data.id) 
    18641870        self.parent.update_theory(data_id=data.id, 
    1865                                        theory=new_plot, 
    1866                                        state=state) 
     1871                                  theory=new_plot, 
     1872                                  state=state) 
    18671873        current_pg = self.fit_panel.get_page_by_id(page_id) 
    18681874        title = new_plot.title 
    18691875        if not source == 'fit' and plot_result: 
    1870             wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    1871                                                title=title)) 
     1876            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title)) 
    18721877        if toggle_mode_on: 
    18731878            wx.PostEvent(self.parent, 
    1874                              NewPlotEvent(group_id=str(page_id) + " Model1D", 
    1875                                                action="Hide")) 
     1879                         NewPlotEvent(group_id=str(page_id) + " Model1D", 
     1880                                      action="Hide")) 
    18761881        else: 
    18771882            # Chisqr in fitpage 
    18781883            if update_chisqr: 
    1879                 wx.PostEvent(current_pg, 
    1880                              Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
    1881                                                                     weight=weight, 
    1882                                                                     fid=fid, 
    1883                                                          page_id=page_id, 
    1884                                                          index=index))) 
     1884                output = self._cal_chisqr(data=data, 
     1885                                          weight=weight, 
     1886                                          fid=fid, 
     1887                                          page_id=page_id, 
     1888                                          index=index) 
     1889                wx.PostEvent(current_pg, Chi2UpdateEvent(output=output)) 
    18851890            else: 
    18861891                self._plot_residuals(page_id=page_id, data=data, fid=fid, 
    1887                                       index=index, weight=weight) 
     1892                                     index=index, weight=weight) 
    18881893 
    18891894        if not number_finite: 
    18901895            logger.error("Using the present parameters the model does not return any finite value. ") 
    18911896            msg = "Computing Error: Model did not return any finite value." 
    1892             wx.PostEvent(self.parent, StatusEvent(status = msg, info="error")) 
     1897            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    18931898        else: 
    18941899            msg = "Computation  completed!" 
    … …  
    19061911                      weight=None, 
    19071912                      toggle_mode_on=False, 
    1908                        update_chisqr=True, source='model'): 
     1913                      update_chisqr=True, source='model'): 
    19091914        """ 
    19101915        draw model in 2D 
    … …  
    19521957    def _draw_model1D(self, model, page_id, data, 
    19531958                      qmin, qmax, smearer=None, 
    1954                 state=None, 
    1955                 weight=None, 
    1956                 fid=None, 
    1957                 toggle_mode_on=False, update_chisqr=True, source='model', 
    1958                 enable1D=True): 
     1959                      state=None, weight=None, fid=None, 
     1960                      toggle_mode_on=False, update_chisqr=True, source='model', 
     1961                      enable1D=True): 
    19591962        """ 
    19601963        Draw model 1D from loaded data1D 
Note: See TracChangeset for help on using the changeset viewer.