Changeset d3b0c77 in sasview for src/sas/sasgui


Ignore:
Timestamp:
Sep 23, 2017 4:24:27 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:
b963b20, fca1f50
Parents:
9706d88 (diff), dba8557 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

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

Location:
src/sas/sasgui
Files:
1 deleted
28 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sasgui/__init__.py

    rd7bb526 rc6bdb3b  
     1import sys 
     2import os 
     3from os.path import exists, expanduser, dirname, realpath, join as joinpath 
     4 
     5 
     6def dirn(path, n): 
     7    path = realpath(path) 
     8    for _ in range(n): 
     9        path = dirname(path) 
     10    return path 
     11 
     12# Set up config directories 
     13def make_user_folder(): 
     14    path = joinpath(expanduser("~"),'.sasview') 
     15    if not exists(path): 
     16        os.mkdir(path) 
     17    return path 
     18 
     19 
     20def find_app_folder(): 
     21    # We are starting out with the following info: 
     22    #     __file__ = .../sas/sasgui/__init__.pyc 
     23    # Check if the sister path .../sas/sasview exists, and use it as the 
     24    # app directory.  This will only be the case if the app is not frozen. 
     25    path = joinpath(dirn(__file__, 2), 'sasview') 
     26    if exists(path): 
     27        return path 
     28 
     29    # If we are running frozen, then root is a parent directory 
     30    if sys.platform == 'darwin': 
     31        # Here is the path to the file on the mac: 
     32        #     .../Sasview.app/Contents/Resources/lib/python2.7/site-packages.zip/sas/sasgui/__init__.pyc 
     33        # We want the path to the Resources directory. 
     34        path = dirn(__file__, 6) 
     35    elif os.name == 'nt': 
     36        # Here is the path to the file on windows: 
     37        #     ../Sasview/library.zip/sas/sasgui/__init__.pyc 
     38        # We want the path to the Sasview directory. 
     39        path = dirn(__file__, 4) 
     40    else: 
     41        raise RuntimeError("Couldn't find the app directory") 
     42    return path 
     43 
     44USER_FOLDER = make_user_folder() 
     45APP_FOLDER = find_app_folder() 
     46 
     47 
     48def get_app_dir(): 
     49    return APP_FOLDER 
     50 
     51def get_user_dir(): 
     52    return USER_FOLDER 
     53 
     54def get_custom_config_path(): 
     55    dirname = os.path.join(get_user_dir(), 'config') 
     56    # If the directory doesn't exist, create it 
     57    if not os.path.exists(dirname): 
     58        os.makedirs(dirname) 
     59    path = os.path.join(dirname, "custom_config.py") 
     60    return path 
     61 
     62_config_cache = None 
     63def get_local_config(): 
     64    global _config_cache 
     65    if not _config_cache: 
     66        _config_cache = _load_config() 
     67    return _config_cache 
     68 
     69def _load_config(): 
     70    import os 
     71    import sys 
     72    import logging 
     73    from sasmodels.custom import load_module_from_path 
     74 
     75    logger = logging.getLogger(__name__) 
     76    dirname = get_app_dir() 
     77    filename = 'local_config.py' 
     78    path = os.path.join(dirname, filename) 
     79    try: 
     80        module = load_module_from_path('sas.sasgui.local_config', path) 
     81        logger.info("GuiManager loaded %s", path) 
     82        return module 
     83    except Exception as exc: 
     84        logger.critical("Error loading %s: %s", path, exc) 
     85        sys.exit() 

  • src/sas/sasgui/guiframe/CategoryInstaller.py

    r65f3930 rd3b0c77  
    1515from collections import defaultdict, OrderedDict 
    1616 
     17from sas.sasgui import get_user_dir 
     18 
    1719USER_FILE = 'categories.json' 
    1820 
    … …  
    2527    Note - class is entirely static! 
    2628    """ 
    27  
    28     def __init__(self): 
    29         """ initialization """ 
    3029 
    3130    @staticmethod 
    … …  
    104103        returns the user data file, eg .sasview/categories.json.json 
    105104        """ 
    106         return os.path.join(CategoryInstaller._get_home_dir(), USER_FILE) 
     105        return os.path.join(get_user_dir(), USER_FILE) 
    107106 
    108107    @staticmethod 

  • src/sas/sasgui/guiframe/__init__.py

    r959eb01 r5a405bd  
    1414    # Check for data path next to exe/zip file. 
    1515    # If we are inside a py2exe zip file, we need to go up 
    16     # to get to the directory containing  
     16    # to get to the directory containing 
    1717    # the media for this module 
    1818    path = os.path.dirname(__file__) 
    … …  
    2727                return module_media_path 
    2828            return media_path 
    29     
     29 
    3030    raise RuntimeError('Could not find guiframe images files') 
    3131 
    … …  
    4040    # Check for data path next to exe/zip file. 
    4141    # If we are inside a py2exe zip file, we need to go up 
    42     # to get to the directory containing  
     42    # to get to the directory containing 
    4343    # the media for this module 
    4444    path = os.path.dirname(__file__) 
    … …  
    5858    """ 
    5959    Return the data files associated with guiframe images . 
    60      
     60 
    6161    The format is a list of (directory, [files...]) pairs which can be 
    6262    used directly in setup(...,data_files=...) for setup.py. 
    … …  
    6464    """ 
    6565    data_files = [] 
    66     path = get_data_path(media="images") 
    67     for f in findall(path): 
    68         data_files.append(('images/icons', [f])) 
    69     path = get_media_path(media="media") 
    70     for f in findall(path): 
    71         data_files.append(('media/guiframe_media', [f])) 
     66    data_files.append(('images/icons', findall(get_data_path("images")))) 
     67    data_files.append(('media/guiframe_media', findall(get_data_path("media")))) 
    7268 
    7369    return data_files 

  • src/sas/sasgui/guiframe/aboutbox.py

    rf2ea95a r724af06  
    2424import os.path 
    2525import os 
    26 try: 
    27     # Try to find a local config 
    28     import imp 
    29     path = os.getcwd() 
    30     if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \ 
    31       (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))): 
    32         fObj, path, descr = imp.find_module('local_config', [path]) 
    33         config = imp.load_module('local_config', fObj, path, descr) 
    34     else: 
    35         # Try simply importing local_config 
    36         import local_config as config 
    37 except: 
    38     # Didn't find local config, load the default 
    39     import config 
     26 
     27from sas.sasgui import get_local_config 
     28config = get_local_config() 
    4029 
    4130def launchBrowser(url): 

  • src/sas/sasgui/guiframe/acknowledgebox.py

    r74c8cd0 r914ba0a  
    1212import wx.lib.hyperlink 
    1313from wx.lib.expando import ExpandoTextCtrl 
    14 import random 
    15 import os.path 
    16 import os 
    17 try: 
    18     # Try to find a local config 
    19     import imp 
    20     path = os.getcwd() 
    21     if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \ 
    22       (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))): 
    23         fObj, path, descr = imp.find_module('local_config', [path]) 
    24         config = imp.load_module('local_config', fObj, path, descr) 
    25     else: 
    26         # Try simply importing local_config 
    27         import local_config as config 
    28 except: 
    29     # Didn't find local config, load the default 
    30     import config 
    3114 
     15from sas.sasgui import get_local_config 
     16config = get_local_config() 
    3217 
    3318class DialogAcknowledge(wx.Dialog): 

  • src/sas/sasgui/guiframe/config.py

    rf80b416e r724af06  
    11""" 
    2     Application settings 
     2Application settings 
    33""" 
    44from __future__ import print_function 
    … …  
    66import time 
    77import os 
     8import logging 
     9 
    810from sas.sasgui.guiframe.gui_style import GUIFRAME 
    911import sas.sasview 
    10 import logging 
    11  
    1212 
    1313logger = logging.getLogger(__name__) 
    … …  
    7575_ansto_logo = os.path.join(icon_path, "ansto_logo.png") 
    7676_tudelft_logo = os.path.join(icon_path, "tudelft_logo.png") 
     77_dls_logo = os.path.join(icon_path, "dls_logo.png") 
    7778_nsf_logo = os.path.join(icon_path, "nsf_logo.png") 
    7879_danse_logo = os.path.join(icon_path, "danse_logo.png") 
    … …  
    147148SAS_OPENCL = None 
    148149 
     150# Time out for updating sasview 
     151UPDATE_TIMEOUT = 2 
     152 
    149153def printEVT(message): 
    150154    if __EVT_DEBUG__: 

  • src/sas/sasgui/guiframe/customdir.py

    r959eb01 rc6bdb3b  
    11# Setup and find Custom config dir 
     2from __future__ import print_function 
     3 
    24import os.path 
     5import logging 
    36import shutil 
    47 
    5 CONF_DIR = 'config'  
    6 APPLICATION_NAME = 'sasview' 
     8from sasmodels.custom import load_module_from_path 
    79 
    8 def _find_usersasview_dir(): 
    9     """ 
    10     Find and return user/.sasview dir 
    11     """ 
    12     return os.path.join(os.path.expanduser("~"), ("." + APPLICATION_NAME)) 
     10from sas.sasgui import get_custom_config_path, get_app_dir 
    1311 
    14 def _find_customconf_dir(): 
    15     """ 
    16     Find path of the config directory. 
    17     The plugin directory is located in the user's home directory. 
    18     """ 
    19     u_dir = _find_usersasview_dir() 
    20     return os.path.join(u_dir, CONF_DIR) 
     12logger = logging.getLogger(__name__) 
    2113 
    22 def _setup_conf_dir(path): 
     14_config_cache = None 
     15def setup_custom_config(): 
    2316    """ 
    2417    Setup the custom config dir and cat file 
    2518    """ 
    26     conf_dir = _find_customconf_dir() 
    27     # If the plugin directory doesn't exist, create it 
    28     if not os.path.isdir(conf_dir): 
    29         os.makedirs(conf_dir) 
    30     config_file = os.path.join(conf_dir, "custom_config.py") 
    31  
    32     # Place example user models as needed 
    33     try: 
    34         if not os.path.isfile(config_file): 
    35             shutil.copyfile(os.path.join(path, "custom_config.py"), config_file) 
    36  
    37         #Adding SAS_OPENCL if it doesn't exist in the config file 
    38         # - to support backcompability 
    39         if not "SAS_OPENCL" in open(config_file).read(): 
    40             open(config_file,"a+").write("SAS_OPENCL = \"None\"\n") 
    41     except: 
    42         # Check for data path next to exe/zip file. 
    43         #Look for maximum n_dir up of the current dir to find plugins dir 
    44         n_dir = 12 
    45         is_dir = False 
    46         f_dir = path 
    47         for i in range(n_dir): 
    48             if i > 1: 
    49                 f_dir, _ = os.path.split(f_dir) 
    50             temp_path = os.path.join(f_dir, "custom_config.py") 
    51             if os.path.isfile(temp_path): 
    52                 shutil.copyfile(temp_path, config_file) 
    53                 is_dir = True 
    54                 break 
    55         if not is_dir: 
    56             raise 
    57     return conf_dir 
     19    global _config_cache 
     20    if not _config_cache: 
     21        _config_cache = _setup_custom_config() 
     22    return _config_cache 
    5823 
    5924 
    60 class SetupCustom(object): 
    61     """ 
    62     implement custom config dir 
    63     """ 
    64     def find_dir(self): 
    65         return _find_customconf_dir() 
    66      
    67     def setup_dir(self, path): 
    68         return _setup_conf_dir(path) 
     25def _setup_custom_config(): 
     26    path = get_custom_config_path() 
     27    if not os.path.isfile(path): 
     28        try: 
     29            # if the custom config file does not exist, copy the default from 
     30            # the app dir 
     31            shutil.copyfile(os.path.join(get_app_dir(), "custom_config.py"), 
     32                            path) 
     33        except Exception: 
     34            logger.error("Could not copy default custom config.") 
     35 
     36    #Adding SAS_OPENCL if it doesn't exist in the config file 
     37    # - to support backcompability 
     38    if not "SAS_OPENCL" in open(path).read(): 
     39        try: 
     40            open(config_file, "a+").write("SAS_OPENCL = \"None\"\n") 
     41        except Exception: 
     42            logger.error("Could not update custom config with SAS_OPENCL.") 
     43 
     44    custom_config = _load_config(path) 
     45    return custom_config 
     46 
     47 
     48def _load_config(path): 
     49    if os.path.exists(path): 
     50        try: 
     51            module = load_module_from_path('sas.sasview.custom_config', path) 
     52            logger.info("GuiManager loaded %s", path) 
     53            return module 
     54        except Exception as exc: 
     55            logger.error("Error loading %s: %s", path, exc) 
     56 
     57    from sas.sasview import custom_config 
     58    logger.info("GuiManager custom_config defaults to sas.sasview.custom_config") 
     59    return custom_config 

  • src/sas/sasgui/guiframe/data_panel.py

    ra1b8fee rc6bdb3b  
    3333from sas.sasgui.guiframe.local_perspectives.plotting.SimplePlot \ 
    3434    import PlotFrame as QucikPlotDialog 
    35 import sas.sasgui.guiframe.config as config 
     35from sas.sasgui import get_local_config 
     36 
     37config = get_local_config() 
    3638 
    3739# Check version 

  • src/sas/sasgui/guiframe/documentation_window.py

    rf80b416e r724af06  
    2727    WX_SUPPORTS_HTML2 = False 
    2828 
    29 from .gui_manager import get_app_dir 
     29from sas.sasgui import get_app_dir 
    3030 
    3131# Don't use wx html renderer on windows. 

  • src/sas/sasgui/guiframe/gui_manager.py

    r2f22db9 r914ba0a  
    2222import re 
    2323import logging 
    24 import httplib 
    2524import traceback 
    2625import urllib 
    27 import urllib2 
    2826import json 
    2927 
     28from matplotlib import _pylab_helpers 
     29 
     30from sas.sasgui import get_local_config, get_app_dir, get_user_dir 
    3031from sas.sasgui.guiframe.events import EVT_CATEGORY 
    3132from sas.sasgui.guiframe.events import EVT_STATUS 
    … …  
    4647from sas.sascalc.dataloader.loader import Loader 
    4748from sas.sasgui.guiframe.proxy import Connection 
    48 from matplotlib import _pylab_helpers 
     49from sas.sasgui.guiframe.customdir import setup_custom_config 
    4950 
    5051logger = logging.getLogger(__name__) 
    51  
    5252warnings.simplefilter("ignore") 
    5353 
    54 def get_app_dir(): 
    55     """ 
    56         The application directory is the one where the default custom_config.py 
    57         file resides. 
    58  
    59         :returns: app_path - the path to the applicatin directory 
    60     """ 
    61     # First, try the directory of the executable we are running 
    62     app_path = sys.path[0] 
    63     if os.path.isfile(app_path): 
    64         app_path = os.path.dirname(app_path) 
    65     if os.path.isfile(os.path.join(app_path, "custom_config.py")): 
    66         app_path = os.path.abspath(app_path) 
    67         logger.info("Using application path: %s", app_path) 
    68         return app_path 
    69  
    70     # Next, try the current working directory 
    71     if os.path.isfile(os.path.join(os.getcwd(), "custom_config.py")): 
    72         logger.info("Using application path: %s", os.getcwd()) 
    73         return os.path.abspath(os.getcwd()) 
    74  
    75     # Finally, try the directory of the sasview module 
    76     # TODO: gui_manager will have to know about sasview until we 
    77     # clean all these module variables and put them into a config class 
    78     # that can be passed by sasview.py. 
    79     logger.debug(sys.executable) 
    80     logger.debug(str(sys.argv)) 
    81     from sas import sasview as sasview 
    82     app_path = os.path.dirname(sasview.__file__) 
    83     logger.debug("Using application path: %s", app_path) 
    84     return app_path 
    85  
    86  
    87 def get_user_directory(): 
    88     """ 
    89         Returns the user's home directory 
    90     """ 
    91     userdir = os.path.join(os.path.expanduser("~"), ".sasview") 
    92     if not os.path.isdir(userdir): 
    93         os.makedirs(userdir) 
    94     return userdir 
    95  
    96  
    97 def _find_local_config(file, path): 
    98     """ 
    99         Find configuration file for the current application 
    100     """ 
    101     config_module = None 
    102     fObj = None 
    103     try: 
    104         fObj, path_config, descr = imp.find_module(file, [path]) 
    105         config_module = imp.load_module(file, fObj, path_config, descr) 
    106     except: 
    107         logger.error("Error loading %s/%s: %s" % (path, file, sys.exc_value)) 
    108     finally: 
    109         if fObj is not None: 
    110             fObj.close() 
    111     logger.debug("GuiManager loaded %s/%s" % (path, file)) 
    112     return config_module 
    113  
    114 # Get APP folder 
    115 PATH_APP = get_app_dir() 
    116 DATAPATH = PATH_APP 
    117  
    118 # GUI always starts from the App folder 
    119 # os.chdir(PATH_APP) 
    120 # Read in the local config, which can either be with the main 
    121 # application or in the installation directory 
    122 config = _find_local_config('local_config', PATH_APP) 
    123 if config is None: 
    124     config = _find_local_config('local_config', os.getcwd()) 
    125     if config is None: 
    126         # Didn't find local config, load the default 
    127         import sas.sasgui.guiframe.config as config 
    128         logger.debug("using default local_config") 
    129     else: 
    130         logger.debug("found local_config in %s" % os.getcwd()) 
    131 else: 
    132     logger.debug("found local_config in %s" % PATH_APP) 
    133  
    134 from sas.sasgui.guiframe.customdir import SetupCustom 
    135 c_conf_dir = SetupCustom().setup_dir(PATH_APP) 
    136 custom_config = _find_local_config('custom_config', c_conf_dir) 
    137 if custom_config is None: 
    138     custom_config = _find_local_config('custom_config', os.getcwd()) 
    139     if custom_config is None: 
    140         msgConfig = "Custom_config file was not imported" 
    141         logger.debug(msgConfig) 
    142     else: 
    143         logger.debug("using custom_config in %s" % os.getcwd()) 
    144 else: 
    145     logger.debug("using custom_config from %s" % c_conf_dir) 
     54config = get_local_config() 
     55custom_config = setup_custom_config() 
    14656 
    14757# read some constants from config 
    … …  
    17787        DEFAULT_OPEN_FOLDER = os.path.abspath(open_folder) 
    17888    else: 
    179         DEFAULT_OPEN_FOLDER = PATH_APP 
     89        DEFAULT_OPEN_FOLDER = get_app_dir() 
    18090    SAS_OPENCL = custom_config.SAS_OPENCL 
    18191except: 
    … …  
    192102    DEFAULT_PERSPECTIVE = None 
    193103    CLEANUP_PLOT = False 
     104    DEFAULT_OPEN_FOLDER = get_app_dir() 
    194105    DEFAULT_OPEN_FOLDER = PATH_APP 
    195106    SAS_OPENCL = None 
    … …  
    265176                if os.path.isfile(ico_file): 
    266177                    self.SetIcon(wx.Icon(ico_file, wx.BITMAP_TYPE_ICO)) 
    267         self.path = PATH_APP 
     178        self.path = get_app_dir() 
    268179        self.application_name = APPLICATION_NAME 
    269180        # Application manager 
    … …  
    540451        try: 
    541452            fd = open(file_name, 'w') 
    542         except: 
     453        except Exception: 
    543454            # On Permission denied: IOError 
    544             temp_dir = get_user_directory() 
     455            temp_dir = get_user_dir() 
    545456            temp_file_name = os.path.join(temp_dir, name) 
    546457            fd = open(temp_file_name, 'w') 
    … …  
    15321443            # want Analysis.  This is NOT an issue on the Mac which does not 
    15331444            # have the extra Window menu item. 
    1534             #      March 2016 Code Camp  -- PDB  
     1445            #      March 2016 Code Camp  -- PDB 
    15351446            Tools_pos = self._menubar.FindMenu("Tools") 
    15361447            self._menubar.Insert(Tools_pos+1, self._applications_menu, 
    … …  
    21632074                logger.info("Failed to connect to www.sasview.org") 
    21642075        self._process_version(version_info, standalone=event is None) 
     2076 
    21652077 
    21662078    def _process_version(self, version_info, standalone=True): 
    … …  
    33513263                if basename.lower() in [app_py, app_exe, app_app, app_base]: 
    33523264                    data_base = sys.argv[1] 
    3353                     input_file = os.path.normpath(os.path.join(DATAPATH, 
     3265                    input_file = os.path.normpath(os.path.join(get_app_dir(), 
    33543266                                                               data_base)) 
    33553267        if input_file is None: 
    … …  
    33663278        # do it only the first time app loaded 
    33673279        # delete unused model folder 
    3368         model_folder = os.path.join(PATH_APP, path) 
     3280        model_folder = os.path.join(get_app_dir(), path) 
    33693281        if os.path.exists(model_folder) and os.path.isdir(model_folder): 
    33703282            if len(os.listdir(model_folder)) > 0: 

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

    rdcb91cf r759a8ab  
    1212from sas.sascalc.dataloader.loader import Loader 
    1313from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException 
     14 
     15from sas.sasgui import get_local_config 
    1416from sas.sasgui.guiframe.plugin_base import PluginBase 
    1517from sas.sasgui.guiframe.events import StatusEvent 
    1618from sas.sasgui.guiframe.gui_style import GUIFRAME 
    1719from sas.sasgui.guiframe.gui_manager import DEFAULT_OPEN_FOLDER 
    18 try: 
    19     # Try to find a local config 
    20     import imp 
    21     path = os.getcwd() 
    22     if(os.path.isfile("%s/%s.py" % (path, 'local_config'))) or \ 
    23         (os.path.isfile("%s/%s.pyc" % (path, 'local_config'))): 
    24         fObj, path, descr = imp.find_module('local_config', [path]) 
    25         config = imp.load_module('local_config', fObj, path, descr) 
    26     else: 
    27         # Try simply importing local_config 
    28         import local_config as config 
    29 except: 
    30     # Didn't find local config, load the default 
    31     import sas.sasgui.guiframe.config as config 
    32  
    33 if config is None: 
    34     import sas.sasgui.guiframe.config as config 
    35  
    36  
     20 
     21config = get_local_config() 
    3722extension_list = [] 
    3823if config.APPLICATION_STATE_EXTENSION is not None: 

  • src/sas/sasgui/guiframe/startup_configuration.py

    r7432acb r914ba0a  
    1  
    21################################################################################ 
    32#This software was developed by the University of Tennessee as part of the 
    43#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    5 #project funded by the US National Science Foundation.  
     4#project funded by the US National Science Foundation. 
    65# 
    76#See the license text in license.txt 
    … …  
    98#copyright 2009, University of Tennessee 
    109################################################################################ 
     10import os 
     11import copy 
     12 
    1113import wx 
    12 import os 
    13 import sys 
    14 import copy 
    15 #import sas.sasgui.guiframe.gui_manager as gui 
    16 from sas.sasgui.guiframe.events import StatusEvent   
     14 
     15from sas.sasgui import get_custom_config_path 
     16from sas.sasgui.guiframe.events import StatusEvent 
    1717from sas.sasgui.guiframe.gui_style import GUIFRAME 
    1818from sas.sasgui.guiframe import gui_manager as CURRENT 
    19 from sas.sasgui.guiframe.customdir  import SetupCustom 
     19 
     20 
    2021# default configuration 
    2122DEFAULT_STRINGS = {'GUIFRAME_WIDTH':-1, 
    … …  
    6263    """ 
    6364    def __init__(self, parent, gui, id=-1, title="Startup Setting"): 
    64         wx.Dialog.__init__(self, parent, id, title,  
     65        wx.Dialog.__init__(self, parent, id, title, 
    6566                           size=(PANEL_WIDTH, PANEL_HEIGHT)) 
    6667        # parent 
    6768        self.parent = parent 
    68         self.path = SetupCustom().find_dir() 
    6969        self._gui = gui 
    70         # font size  
     70        # font size 
    7171        self.SetWindowVariant(variant=FONT_VARIANT) 
    7272        self.current_string = copy.deepcopy(CURRENT_STRINGS) 
    … …  
    7676        title_text = wx.StaticText(self, id=wx.NewId(), label='Set interface configuration') 
    7777 
    78         default_bt = wx.RadioButton(self, -1, 'Default View', (15, 30),  
     78        default_bt = wx.RadioButton(self, -1, 'Default View', (15, 30), 
    7979                                    style=wx.RB_GROUP) 
    8080        default_bt.Bind(wx.EVT_RADIOBUTTON, self.OnDefault) 
    … …  
    8787        note_txt = wx.StaticText(self, -1, msg, (15, 75)) 
    8888        note_txt.SetForegroundColour("black") 
    89          
     89 
    9090        hbox = wx.BoxSizer(wx.HORIZONTAL) 
    9191        okButton = wx.Button(self, wx.ID_OK, 'Set', size=(70, 25)) 
    92         closeButton = wx.Button(self,wx.ID_CANCEL, 'Cancel', size=(70, 25)) 
     92        closeButton = wx.Button(self, wx.ID_CANCEL, 'Cancel', size=(70, 25)) 
    9393        hbox.Add(closeButton, 1, wx.RIGHT, 5) 
    9494        hbox.Add(okButton, 1, wx.RIGHT, 5) 
    … …  
    102102        self.SetSizer(vbox) 
    103103 
    104          
     104 
    105105    def OnDefault(self, event=None): 
    106106        """ 
    … …  
    111111        self.return_string = copy.deepcopy(DEFAULT_STRINGS) 
    112112        return self.return_string 
    113          
     113 
    114114    def OnCurrent(self, event=None): 
    115115        """ 
    … …  
    134134                p_size = CURRENT_STRINGS['PLOPANEL_WIDTH'] 
    135135            self.current_string['PLOPANEL_WIDTH'] = p_size 
    136              
     136 
    137137            try: 
    138138                control_frame = self.parent.get_current_perspective().frame 
    … …  
    143143                self.current_string['CONTROL_WIDTH'] = -1 
    144144                self.current_string['CONTROL_HEIGHT'] = -1 
    145                  
     145 
    146146            data_pw, _ = self.parent.panels["data_panel"].frame.GetSizeTuple() 
    147147            if data_pw is None: 
    148148                data_pw = CURRENT_STRINGS['DATAPANEL_WIDTH'] 
    149149            self.current_string['DATAPANEL_WIDTH'] = data_pw 
    150              
     150 
    151151            #label = self.parent._data_panel_menu.GetText() 
    152152            label = self.parent.panels['data_panel'].frame.IsShown() 
    … …  
    155155            else: 
    156156                self.current_string['DATALOADER_SHOW'] = False 
    157                  
     157 
    158158            if self.parent._toolbar.IsShown(): 
    159159                self.current_string['TOOLBAR_SHOW'] = True 
    160160            else: 
    161161                self.current_string['TOOLBAR_SHOW'] = False 
    162                  
     162 
    163163            style = self._gui & GUIFRAME.FLOATING_PANEL 
    164             if style == GUIFRAME.FLOATING_PANEL:  
     164            if style == GUIFRAME.FLOATING_PANEL: 
    165165                self.current_string['FIXED_PANEL'] = False 
    166166            else: 
    167167                self.current_string['FIXED_PANEL'] = True 
    168                  
     168 
    169169            if self.parent.panels['default'].frame.IsShown(): 
    170170                self.current_string['WELCOME_PANEL_SHOW'] = True 
    … …  
    182182            self.current_string['DEFAULT_OPEN_FOLDER'] = location 
    183183                        #self.parent._default_save_location.ascii_letters 
    184              
     184 
    185185        except: 
    186186            raise 
    … …  
    188188        self.return_string = self.current_string 
    189189        return self.return_string 
    190      
     190 
     191 
    191192    def write_custom_config(self): 
    192193        """ 
    193             Write custom configuration 
    194         """ 
    195         fname = os.path.join(self.path, 'custom_config.py') 
    196         self.write_string(fname, self.return_string) 
    197  
    198     def write_string(self, fname, strings): 
    199         """ 
    200         Write and Save file 
    201         """ 
    202          
    203         try: 
    204             out_f =  open(fname,'w') 
    205         except : 
    206             raise  #RuntimeError, "Error: Can not change the configuration..." 
    207         out_f.write("#Application appearance custom configuration\n" ) 
    208         for key, item in strings.iteritems(): 
    209             if (key == 'DEFAULT_PERSPECTIVE') or \ 
    210                 (key == 'DEFAULT_OPEN_FOLDER' and item is not None): 
    211                 out_f.write("%s = \"%s\"\n" % (key,str(item))) 
    212             else: 
    213                 out_f.write("%s = %s\n" % (key,str(item))) 
    214      
    215         out_f.close()  
    216          
     194        Write custom configuration 
     195        """ 
     196        path = get_custom_config_path() 
     197        with open(path, 'w') as out_f: 
     198            out_f.write("#Application appearance custom configuration\n") 
     199            for key, item in self.return_string.iteritems(): 
     200                if (key == 'DEFAULT_PERSPECTIVE') or \ 
     201                    (key == 'DEFAULT_OPEN_FOLDER' and item != None): 
     202                    out_f.write("%s = \"%s\"\n" % (key, str(item))) 
     203                else: 
     204                    out_f.write("%s = %s\n" % (key, str(item))) 

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

    r959eb01 r5a405bd  
    1818    path = os.path.dirname(__file__) 
    1919    #Look for maximum n_dir up of the current dir to find media 
    20     
     20 
    2121    #for i in range(n_dir): 
    2222    i = 0 
    … …  
    3030             return media_path 
    3131        i += 1 
    32     
     32 
    3333    raise RuntimeError('Could not find calculator media files') 
    3434 
    … …  
    3636    """ 
    3737    Return the data files associated with media calculator. 
    38      
     38 
    3939    The format is a list of (directory, [files...]) pairs which can be 
    4040    used directly in setup(...,data_files=...) for setup.py. 
    … …  
    4242    """ 
    4343    data_files = [] 
    44     path = get_data_path(media="media") 
    45     for f in findall(path): 
    46         data_files.append(('media/calculator_media', [f])) 
     44    data_files.append(('media/calculator_media', findall(get_data_path("media")))) 
    4745    return data_files 

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

    r959eb01 r12d3e0e  
    1313    # Check for data path next to exe/zip file. 
    1414    # If we are inside a py2exe zip file, we need to go up 
    15     # to get to the directory containing  
     15    # to get to the directory containing 
    1616    # the media for this module 
    1717    path = os.path.dirname(__file__) 
    … …  
    2626                return module_media_path 
    2727            return media_path 
    28     
     28 
    2929    raise RuntimeError('Could not find models media files') 
    3030 
    … …  
    3232    """ 
    3333    Return the data files associated with media. 
    34      
     34 
    3535    The format is a list of (directory, [files...]) pairs which can be 
    3636    used directly in setup(...,data_files=...) for setup.py. 
    … …  
    3838    """ 
    3939    data_files = [] 
    40     path = os.path.dirname(__file__) 
    41     p_path = os.path.join(path, 'plugin_models') 
    42     for f in findall(p_path): 
    43         data_files.append(('plugin_models', [f])) 
    44     # path = get_data_path(media="media") 
    45     for f in findall(path): 
    46         data_files.append(('media/fitting_media', [f])) 
    47      
     40    # Note: windows installer requires the plugin_models directory 
     41    plugin_models = os.path.join(os.path.dirname(__file__), "plugin_models") 
     42    data_files.append(('plugin_models', findall(plugin_models))) 
     43    data_files.append(('media/fitting_media', findall(get_data_path("media")))) 
     44 
    4845    return data_files 

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

    r69363c7 rd3b0c77  
    1212import logging 
    1313import traceback 
     14from Queue import Queue 
     15from threading import Thread 
    1416from collections import defaultdict 
    1517 
    … …  
    248250        self.set_layout() 
    249251 
     252        # Setting up a thread for the fitting 
     253        self.threaded_draw_queue = Queue() 
     254 
     255        self.draw_worker_thread = Thread(target = self._threaded_draw_worker, 
     256                                         args = (self.threaded_draw_queue,)) 
     257        self.draw_worker_thread.setDaemon(True) 
     258        self.draw_worker_thread.start() 
     259 
     260        # And a home for the thread submission times 
     261        self.last_time_fit_submitted = 0.00 
     262 
    250263    def set_index_model(self, index): 
    251264        """ 
    … …  
    17351748        :param chisqr: update chisqr value [bool] 
    17361749        """ 
    1737         wx.CallAfter(self._draw_model_after, update_chisqr, source) 
     1750        self.threaded_draw_queue.put([copy.copy(update_chisqr), copy.copy(source)]) 
     1751 
     1752    def _threaded_draw_worker(self, threaded_draw_queue): 
     1753        while True: 
     1754            # sit and wait for the next task 
     1755            next_task = threaded_draw_queue.get() 
     1756 
     1757            # sleep for 1/10th second in case some other tasks accumulate 
     1758            time.sleep(0.1) 
     1759 
     1760            # skip all intermediate tasks 
     1761            while self.threaded_draw_queue.qsize() > 0: 
     1762                self.threaded_draw_queue.task_done() 
     1763                next_task = self.threaded_draw_queue.get() 
     1764 
     1765            # and finally, do the task 
     1766            self._draw_model_after(*next_task) 
     1767            threaded_draw_queue.task_done() 
    17381768 
    17391769    def _draw_model_after(self, update_chisqr=True, source='model'): 
    … …  
    17571787            toggle_mode_on = self.model_view.IsEnabled() 
    17581788            is_2d = self._is_2D() 
     1789 
    17591790            self._manager.draw_model(self.model, 
    17601791                                     data=self.data, 

  • src/sas/sasgui/perspectives/invariant/__init__.py

    r959eb01 r5a405bd  
    1515    # Check for data path next to exe/zip file. 
    1616    # If we are inside a py2exe zip file, we need to go up 
    17     # to get to the directory containing  
     17    # to get to the directory containing 
    1818    # the media for this module 
    1919    path = os.path.dirname(__file__) 
    … …  
    2828                return module_media_path 
    2929            return media_path 
    30     
     30 
    3131    raise RuntimeError('Could not find invariant media files') 
    3232 
    … …  
    3434    """ 
    3535    Return the data files associated with media invariant. 
    36      
     36 
    3737    The format is a list of (directory, [files...]) pairs which can be 
    3838    used directly in setup(...,data_files=...) for setup.py. 
    … …  
    4040    """ 
    4141    data_files = [] 
    42     path = get_data_path(media="media") 
    43     for f in findall(path): 
    44         data_files.append(('media/invariant_media', [f])) 
     42    data_files.append(('media/invariant_media', findall(get_data_path("media")))) 
    4543    return data_files 

  • src/sas/sasgui/plottools/__init__.py

    rd7bb526 refe730d  
    1 import config 
    21from PlotPanel import PlotPanel 
    32from plottables import Data1D, Theory1D 

  • src/sas/sasgui/plottools/config.py

    rd7bb526 ra2a1c20  
    3838    import pkg_resources 
    3939    pkg_resources.require("matplotlib>=" + plot_version) 
    40 except: 
     40except ImportError: 
    4141    from distutils.version import LooseVersion as Version 
    4242    if Version(matplotlib.__version__) < Version(plot_version): 

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

    r23359ccb r69363c7  
    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 
    … …  
    335338            list_fnames = os.listdir(self.plugin_dir) 
    336339            # fake existing regular model name list 
    337             m_list = [model + ".py" for model in self.model_list] 
     340            m_list = [model.name + ".py" for model in self.model_list] 
    338341            list_fnames.append(m_list) 
    339342            if t_fname in list_fnames and title != mname: 
    … …  
    533536            desc_line = "\nmodel_info.description = '{}'".format(description) 
    534537        name = os.path.splitext(os.path.basename(self.fname))[0] 
    535         output = SUM_TEMPLATE.format(name=name, model1=model1_name,  
     538        output = SUM_TEMPLATE.format(name=name, model1=model1_name, 
    536539            model2=model2_name, operator=self._operator, desc_line=desc_line) 
    537540        with open(self.fname, 'w') as out_f: 
    … …  
    789792                    exec "float(math.%s)" % item 
    790793                    self.math_combo.Append(str(item)) 
    791                 except: 
     794                except Exception: 
    792795                    self.math_combo.Append(str(item) + "()") 
    793796        self.math_combo.Bind(wx.EVT_COMBOBOX, self._on_math_select) 
    … …  
    914917            msg = "Name exists already." 
    915918 
    916         # Prepare the messagebox 
     919        # 
    917920        if self.base is not None and not msg: 
    918921            self.base.update_custom_combo() 
    919             # Passed exception in import test as it will fail for sasmodels.sasview_model class 
    920             # Should add similar test for new style? 
    921             Model = None 
    922             try: 
    923                 exec "from %s import Model" % name 
    924             except: 
    925                 logger.error(sys.exc_value) 
    926922 
    927923        # Prepare the messagebox 
    … …  
    956952        :param func_str: content of func; Strings 
    957953        """ 
    958         try: 
    959             out_f = open(fname, 'w') 
    960         except: 
    961             raise 
    962         # Prepare the content of the function 
    963         lines = CUSTOM_TEMPLATE.split('\n') 
    964  
    965         has_scipy = func_str.count("scipy.") 
    966         if has_scipy: 
    967             lines.insert(0, 'import scipy') 
    968  
    969         # Think about 2D later 
    970         #self.is_2d = func_str.count("#self.ndim = 2") 
    971         #line_2d = '' 
    972         #if self.is_2d: 
    973         #    line_2d = CUSTOM_2D_TEMP.split('\n') 
    974  
    975         # Also think about test later 
    976         #line_test = TEST_TEMPLATE.split('\n') 
    977         #local_params = '' 
    978         #spaces = '        '#8spaces 
    979         spaces4  = ' '*4 
    980         spaces13 = ' '*13 
    981         spaces16 = ' '*16 
     954        out_f = open(fname, 'w') 
     955 
     956        out_f.write(CUSTOM_TEMPLATE % { 
     957            'name': name, 
     958            'title': 'User model for ' + name, 
     959            'description': desc_str, 
     960            'date': datetime.datetime.now().strftime('%YYYY-%mm-%dd'), 
     961        }) 
     962 
     963        # Write out parameters 
    982964        param_names = []    # to store parameter names 
    983         has_scipy = func_str.count("scipy.") 
    984         if has_scipy: 
    985             lines.insert(0, 'import scipy') 
    986  
    987         # write function here 
    988         for line in lines: 
    989             # The location where to put the strings is 
    990             # hard-coded in the template as shown below. 
    991             out_f.write(line + '\n') 
    992             if line.count('#name'): 
    993                 out_f.write('name = "%s" \n' % name) 
    994             elif line.count('#title'): 
    995                 out_f.write('title = "User model for %s"\n' % name) 
    996             elif line.count('#description'): 
    997                 out_f.write('description = "%s"\n' % desc_str) 
    998             elif line.count('#parameters'): 
    999                 out_f.write('parameters = [ \n') 
    1000                 for param_line in param_str.split('\n'): 
    1001                     p_line = param_line.lstrip().rstrip() 
    1002                     if p_line: 
    1003                         pname, pvalue, desc = self.get_param_helper(p_line) 
    1004                         param_names.append(pname) 
    1005                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', '%s'],\n" % (spaces16, pname, pvalue, desc)) 
    1006                 for param_line in pd_param_str.split('\n'): 
    1007                     p_line = param_line.lstrip().rstrip() 
    1008                     if p_line: 
    1009                         pname, pvalue, desc = self.get_param_helper(p_line) 
    1010                         param_names.append(pname) 
    1011                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', '%s'],\n" % (spaces16, pname, pvalue, desc)) 
    1012                 out_f.write('%s]\n' % spaces13) 
    1013  
    1014         # No form_volume or ER available in simple model editor 
    1015         out_f.write('def form_volume(*arg): \n') 
    1016         out_f.write('    return 1.0 \n') 
    1017         out_f.write('\n') 
    1018         out_f.write('def ER(*arg): \n') 
    1019         out_f.write('    return 1.0 \n') 
    1020  
    1021         # function to compute 
    1022         out_f.write('\n') 
    1023         out_f.write('def Iq(x ') 
    1024         for name in param_names: 
    1025             out_f.write(', %s' % name) 
    1026         out_f.write('):\n') 
     965        pd_params = [] 
     966        out_f.write('parameters = [ \n') 
     967        out_f.write('#   ["name", "units", default, [lower, upper], "type", "description"],\n') 
     968        for pname, pvalue, desc in self.get_param_helper(param_str): 
     969            param_names.append(pname) 
     970            out_f.write("    ['%s', '', %s, [-inf, inf], '', '%s'],\n" 
     971                        % (pname, pvalue, desc)) 
     972        for pname, pvalue, desc in self.get_param_helper(pd_param_str): 
     973            param_names.append(pname) 
     974            pd_params.append(pname) 
     975            out_f.write("    ['%s', '', %s, [-inf, inf], 'volume', '%s'],\n" 
     976                        % (pname, pvalue, desc)) 
     977        out_f.write('    ]\n') 
     978 
     979        # Write out function definition 
     980        out_f.write('def Iq(%s):\n' % ', '.join(['x'] + param_names)) 
     981        out_f.write('    """Absolute scattering"""\n') 
     982        if "scipy." in func_str: 
     983            out_f.write('    import scipy') 
     984        if "numpy." in func_str: 
     985            out_f.write('    import numpy') 
     986        if "np." in func_str: 
     987            out_f.write('    import numpy as np') 
    1027988        for func_line in func_str.split('\n'): 
    1028989            out_f.write('%s%s\n' % (spaces4, func_line)) 
    1029  
    1030         Iqxy_string = 'return Iq(numpy.sqrt(x**2+y**2) ' 
    1031  
     990        out_f.write('## uncomment the following if Iq works for vector x\n') 
     991        out_f.write('#Iq.vectorized = True\n') 
     992 
     993        # If polydisperse, create place holders for form_volume, ER and VR 
     994        if pd_params: 
     995            out_f.write('\n') 
     996            out_f.write(CUSTOM_TEMPLATE_PD % {'args': ', '.join(pd_params)}) 
     997 
     998        # Create place holder for Iqxy 
    1032999        out_f.write('\n') 
    1033         out_f.write('def Iqxy(x, y ') 
    1034         for name in param_names: 
    1035             out_f.write(', %s' % name) 
    1036             Iqxy_string += ', ' + name 
    1037         out_f.write('):\n') 
    1038         Iqxy_string += ')' 
    1039         out_f.write('%s%s\n' % (spaces4, Iqxy_string)) 
     1000        out_f.write('#def Iqxy(%s):\n' % ', '.join(["x", "y"] + param_names)) 
     1001        out_f.write('#    """Absolute scattering of oriented particles."""\n') 
     1002        out_f.write('#    ...\n') 
     1003        out_f.write('#    return oriented_form(x, y, args)\n') 
     1004        out_f.write('## uncomment the following if Iqxy works for vector x, y\n') 
     1005        out_f.write('#Iqxy.vectorized = True\n') 
    10401006 
    10411007        out_f.close() 
    10421008 
    1043     def get_param_helper(self, line): 
    1044         """ 
    1045         Get string in line to define the params dictionary 
    1046  
    1047         :param line: one line of string got from the param_str 
    1048         """ 
    1049         items = line.split(";") 
    1050         for item in items: 
    1051             name = item.split("=")[0].strip() 
    1052             description = "" 
    1053             try: 
    1054                 value = item.split("=")[1].strip() 
    1055                 if value.count("#"): 
    1056                     # If line ends in a comment, remove it before parsing float 
    1057                     index = value.index("#") 
    1058                     description = value[(index + 1):].strip() 
    1059                     value = value[:value.index("#")].strip() 
    1060                 float(value) 
    1061             except ValueError: 
    1062                 value = 1.0 # default 
    1063  
    1064         return name, value, description 
     1009    def get_param_helper(self, param_str): 
     1010        """ 
     1011        yield a sequence of name, value pairs for the parameters in param_str 
     1012 
     1013        Parameters can be defined by one per line by name=value, or multiple 
     1014        on the same line by separating the pairs by semicolon or comma.  The 
     1015        value is optional and defaults to "1.0". 
     1016        """ 
     1017        for line in param_str.replace(';', ',').split('\n'): 
     1018            for item in line.split(','): 
     1019                defn, desc = item.split('#', 1) if '#' in item else (item, '') 
     1020                name, value = defn.split('=', 1) if '=' in defn else (defn, '1.0') 
     1021                if name: 
     1022                    yield [v.strip() for v in (name, value, desc)] 
    10651023 
    10661024    def set_function_helper(self, line): 
    … …  
    10961054        running "file:///...." 
    10971055 
    1098     :param evt: Triggers on clicking the help button 
    1099     """ 
     1056        :param evt: Triggers on clicking the help button 
     1057        """ 
    11001058 
    11011059        _TreeLocation = "user/sasgui/perspectives/fitting/fitting_help.html" 
    … …  
    11401098## Templates for plugin models 
    11411099 
    1142 CUSTOM_TEMPLATE = """ 
     1100CUSTOM_TEMPLATE = '''\ 
     1101r""" 
     1102Definition 
     1103---------- 
     1104 
     1105Calculates %(name)s. 
     1106 
     1107%(description)s 
     1108 
     1109References 
     1110---------- 
     1111 
     1112Authorship and Verification 
     1113--------------------------- 
     1114 
     1115* **Author:** --- **Date:** %(date)s 
     1116* **Last Modified by:** --- **Date:** %(date)s 
     1117* **Last Reviewed by:** --- **Date:** %(date)s 
     1118""" 
     1119 
    11431120from math import * 
    1144 import os 
    1145 import sys 
    1146 import numpy 
    1147  
    1148 #name 
    1149  
    1150 #title 
    1151  
    1152 #description 
    1153  
    1154 #parameters 
    1155  
    1156 """ 
    1157  
    1158 CUSTOM_2D_TEMP = """ 
    1159     def run(self, x=0.0, y=0.0): 
    1160         if x.__class__.__name__ == 'list': 
    1161             x_val = x[0] 
    1162             y_val = y[0]*0.0 
    1163             return self.function(x_val, y_val) 
    1164         elif x.__class__.__name__ == 'tuple': 
    1165             msg = "Tuples are not allowed as input to BaseComponent models" 
    1166             raise ValueError, msg 
    1167         else: 
    1168             return self.function(x, 0.0) 
    1169     def runXY(self, x=0.0, y=0.0): 
    1170         if x.__class__.__name__ == 'list': 
    1171             return self.function(x, y) 
    1172         elif x.__class__.__name__ == 'tuple': 
    1173             msg = "Tuples are not allowed as input to BaseComponent models" 
    1174             raise ValueError, msg 
    1175         else: 
    1176             return self.function(x, y) 
    1177     def evalDistribution(self, qdist): 
    1178         if qdist.__class__.__name__ == 'list': 
    1179             msg = "evalDistribution expects a list of 2 ndarrays" 
    1180             if len(qdist)!=2: 
    1181                 raise RuntimeError, msg 
    1182             if qdist[0].__class__.__name__ != 'ndarray': 
    1183                 raise RuntimeError, msg 
    1184             if qdist[1].__class__.__name__ != 'ndarray': 
    1185                 raise RuntimeError, msg 
    1186             v_model = numpy.vectorize(self.runXY, otypes=[float]) 
    1187             iq_array = v_model(qdist[0], qdist[1]) 
    1188             return iq_array 
    1189         elif qdist.__class__.__name__ == 'ndarray': 
    1190             v_model = numpy.vectorize(self.runXY, otypes=[float]) 
    1191             iq_array = v_model(qdist) 
    1192             return iq_array 
    1193 """ 
    1194 TEST_TEMPLATE = """ 
    1195 ###################################################################### 
    1196 ## THIS IS FOR TEST. DO NOT MODIFY THE FOLLOWING LINES!!!!!!!!!!!!!!!! 
    1197 if __name__ == "__main__": 
    1198     m= Model() 
    1199     out1 = m.runXY(0.0) 
    1200     out2 = m.runXY(0.01) 
    1201     isfine1 = numpy.isfinite(out1) 
    1202     isfine2 = numpy.isfinite(out2) 
    1203     print "Testing the value at Q = 0.0:" 
    1204     print out1, " : finite? ", isfine1 
    1205     print "Testing the value at Q = 0.01:" 
    1206     print out2, " : finite? ", isfine2 
    1207     if isfine1 and isfine2: 
    1208         print "===> Simple Test: Passed!" 
    1209     else: 
    1210         print "===> Simple Test: Failed!" 
    1211 """ 
     1121from numpy import inf 
     1122 
     1123name = "%(name)s" 
     1124title = "%(title)s" 
     1125description = """%(description)s""" 
     1126 
     1127''' 
     1128 
     1129CUSTOM_TEMPLATE_PD = '''\ 
     1130def form_volume(%(args)s): 
     1131    """ 
     1132    Volume of the particles used to compute absolute scattering intensity 
     1133    and to weight polydisperse parameter contributions. 
     1134    """ 
     1135    return 0.0 
     1136 
     1137def ER(%(args)s): 
     1138    """ 
     1139    Effective radius of particles to be used when computing structure factors. 
     1140 
     1141    Input parameters are vectors ranging over the mesh of polydispersity values. 
     1142    """ 
     1143    return 0.0 
     1144 
     1145def VR(%(args)s): 
     1146    """ 
     1147    Volume ratio of particles to be used when computing structure factors. 
     1148 
     1149    Input parameters are vectors ranging over the mesh of polydispersity values. 
     1150    """ 
     1151    return 1.0 
     1152''' 
     1153 
    12121154SUM_TEMPLATE = """ 
    12131155from sasmodels.core import load_model_info 
    … …  
    12191161""" 
    12201162if __name__ == "__main__": 
    1221 #    app = wx.PySimpleApp() 
    12221163    main_app = wx.App() 
    12231164    main_frame = TextDialog(id=1, model_list=["SphereModel", "CylinderModel"], 
    1224                        plugin_dir='../fitting/plugin_models') 
     1165                            plugin_dir='../fitting/plugin_models') 
    12251166    main_frame.ShowModal() 
    12261167    main_app.MainLoop() 
    1227  
    1228 #if __name__ == "__main__": 
    1229 #    from sas.sasgui.perspectives.fitting import models 
    1230 #    dir_path = models.find_plugins_dir() 
    1231 #    app = wx.App() 
    1232 #    window = EditorWindow(parent=None, base=None, path=dir_path, title="Editor") 
    1233 #    app.MainLoop() 

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

    r7432acb r50fcb09  
    55import wx.lib.newevent 
    66import math 
     7 
     8from sas.sascalc.fit.qsmearing import smear_selection 
     9 
    710from sas.sasgui.guiframe.events import StatusEvent 
    811from sas.sasgui.guiframe.events import NewPlotEvent 
     12from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent 
     13from sas.sasgui.perspectives.fitting.fitpage import FitPage 
     14from sas.sasgui.perspectives.fitting.fitpage import check_data_validity 
    915 
    1016(Chi2UpdateEvent, EVT_CHI2_UPDATE) = wx.lib.newevent.NewEvent() 
    … …  
    1319SMEAR_SIZE_L = 0.00 
    1420SMEAR_SIZE_H = 0.00 
    15  
    16 from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent 
    17 from sas.sascalc.data_util.qsmearing import smear_selection 
    18 from sas.sasgui.perspectives.fitting.fitpage import FitPage 
    19 from sas.sasgui.perspectives.fitting.fitpage import check_data_validity 
    2021 
    2122class BatchFitPage(FitPage): 
    … …  
    7677#         """ 
    7778#         is_2Ddata = False 
    78 #          
     79# 
    7980#         # Check if data is 2D 
    8081#         if self.data.__class__.__name__ ==  "Data2D" or \ 
    8182#                         self.enable2D: 
    8283#             is_2Ddata = True 
    83 #              
    84 #         title = "Fitting"      
     84# 
     85#         title = "Fitting" 
    8586#         self._get_smear_info() 
    86 #          
     87# 
    8788#         #Sizers 
    8889#         box_description_range = wx.StaticBox(self, wx.ID_ANY, str(title)) 
    89 #         boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL)       
     90#         boxsizer_range = wx.StaticBoxSizer(box_description_range, wx.VERTICAL) 
    9091#         self.sizer_set_smearer = wx.BoxSizer(wx.VERTICAL) 
    9192#         #sizer_smearer = wx.BoxSizer(wx.HORIZONTAL) 
    … …  
    9394#         self.sizer_set_masking = wx.BoxSizer(wx.HORIZONTAL) 
    9495#         sizer_chi2 = wx.BoxSizer(wx.VERTICAL) 
    95 #  
     96# 
    9697#         sizer_fit = wx.GridSizer(2, 4, 2, 6) 
    9798#         #Fit button 
    … …  
    100101#         self.btFit.Bind(wx.EVT_BUTTON, self._onFit, id= self.btFit.GetId()) 
    101102#         self.btFit.SetToolTipString("Start fitting.") 
    102 #  
     103# 
    103104#         # Update and Draw button 
    104105#         self.draw_button = wx.Button(self, self._ids.next(), 'Compute', size=(88, 24)) 
    105106#         self.draw_button.Bind(wx.EVT_BUTTON, \ 
    106107#                               self._onDraw,id=self.draw_button.GetId()) 
    107 #         self.draw_button.SetToolTipString("Compute and Draw.")   
     108#         self.draw_button.SetToolTipString("Compute and Draw.") 
    108109#         sizer_fit.Add(self.draw_button, 0, 0) 
    109 #         sizer_fit.Add(self.btFit, 0, 0)  
     110#         sizer_fit.Add(self.btFit, 0, 0) 
    110111#         sizer_chi2.Add((-1, 5)) 
    111112#         # get smear_selection 
    … …  
    114115#          #2D data? default 
    115116#         is_2Ddata = False 
    116 #          
     117# 
    117118#         #check if it is 2D data 
    118119#         if self.data.__class__.__name__ ==  "Data2D" or \ 
    119120#                         self.enable2D: 
    120121#             is_2Ddata = True 
    121 #              
     122# 
    122123#         self.sizer5.Clear(True) 
    123 #       
     124# 
    124125#         self.qmin  = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20), 
    125 #                                           style=wx.TE_PROCESS_ENTER,  
     126#                                           style=wx.TE_PROCESS_ENTER, 
    126127#                                     text_enter_callback = self._onQrangeEnter) 
    127128#         self.qmin.SetValue(str(self.qmin_x)) 
    128129#         self.qmin.SetToolTipString("Minimun value of Q in linear scale.") 
    129 #       
     130# 
    130131#         self.qmax  = ModelTextCtrl(self, wx.ID_ANY, size=(_BOX_WIDTH, 20), 
    131 #                                           style=wx.TE_PROCESS_ENTER,  
     132#                                           style=wx.TE_PROCESS_ENTER, 
    132133#                                         text_enter_callback=self._onQrangeEnter) 
    133134#         self.qmax.SetValue(str(self.qmax_x)) 
    134135#         self.qmax.SetToolTipString("Maximum value of Q in linear scale.") 
    135 #          
     136# 
    136137#         id = self._ids.next() 
    137138#         self.reset_qrange =wx.Button(self, id, 'Reset', size=(77, 20)) 
    138 #        
     139# 
    139140#         self.reset_qrange.Bind(wx.EVT_BUTTON, self.on_reset_clicked, id=id) 
    140141#         self.reset_qrange.SetToolTipString(\ 
    141142#                                     "Reset Q range to the default values") 
    142 #       
     143# 
    143144#         sizer_horizontal = wx.BoxSizer(wx.HORIZONTAL) 
    144145#         sizer = wx.GridSizer(2, 4, 2, 6) 
    145 #  
     146# 
    146147#         self.btEditMask = wx.Button(self, self._ids.next(),'Editor', size=(88, 23)) 
    147 #         self.btEditMask.Bind(wx.EVT_BUTTON,  
     148#         self.btEditMask.Bind(wx.EVT_BUTTON, 
    148149#                              self._onMask,id=self.btEditMask.GetId()) 
    149150#         self.btEditMask.SetToolTipString("Edit Mask.") 
    150151#         self.EditMask_title = wx.StaticText(self, wx.ID_ANY, ' Masking(2D)') 
    151 #  
     152# 
    152153#         sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Q range')) 
    153154#         sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Min[1/A]')) 
    154155#         sizer.Add(wx.StaticText(self, wx.ID_ANY, ' Max[1/A]')) 
    155156#         sizer.Add(self.EditMask_title) 
    156 #   
    157 #         sizer.Add(self.reset_qrange)    
     157# 
     158#         sizer.Add(self.reset_qrange) 
    158159#         sizer.Add(self.qmin) 
    159160#         sizer.Add(self.qmax) 
    160 #  
     161# 
    161162#         sizer.Add(self.btEditMask) 
    162 #         boxsizer_range.Add(sizer_chi2)  
     163#         boxsizer_range.Add(sizer_chi2) 
    163164#         boxsizer_range.Add((10, 10)) 
    164165#         boxsizer_range.Add(sizer) 
    165 #          
     166# 
    166167#         boxsizer_range.Add((10, 15)) 
    167168#         boxsizer_range.Add(sizer_fit) 
    168169#         if is_2Ddata: 
    169 #             self.btEditMask.Enable()   
    170 #             self.EditMask_title.Enable()  
     170#             self.btEditMask.Enable() 
     171#             self.EditMask_title.Enable() 
    171172#         else: 
    172 #             self.btEditMask.Disable()   
     173#             self.btEditMask.Disable() 
    173174#             self.EditMask_title.Disable() 
    174 #  
     175# 
    175176#         ## save state 
    176177#         #self.save_current_state() 
    177 #  
     178# 
    178179#         self.sizer5.Add(boxsizer_range, 0, wx.EXPAND | wx.ALL, 10) 
    179180#         self.sizer5.Layout() 
    180 #         
    181 #     def _on_select_model(self, event=None):  
     181# 
     182#     def _on_select_model(self, event=None): 
    182183#         """ 
    183184#         call back for model selection 
    184 #         """   
    185 #          
    186 #         self.Show(False)     
    187 #         self._on_select_model_helper()  
    188 #         self.set_model_param_sizer(self.model)                    
     185#         """ 
     186# 
     187#         self.Show(False) 
     188#         self._on_select_model_helper() 
     189#         self.set_model_param_sizer(self.model) 
    189190#         if self.model is None: 
    190191#             self._set_bookmark_flag(False) 
    … …  
    199200#         self.state.structurecombobox = self.structurebox.GetCurrentSelection() 
    200201#         self.state.formfactorcombobox = self.formfactorbox.GetCurrentSelection() 
    201 #        
     202# 
    202203#         if self.model is not None: 
    203204#             self._set_copy_flag(True) 
    … …  
    206207#                 self._set_bookmark_flag(False) 
    207208#                 self._keep.Enable(False) 
    208 #                  
     209# 
    209210#             temp_smear = None 
    210211#             ## event to post model to fit to fitting plugins 
    211212#             (ModelEventbox, _) = wx.lib.newevent.NewEvent() 
    212 #           
    213 #             ## set smearing value whether or not  
     213# 
     214#             ## set smearing value whether or not 
    214215#             #    the data contain the smearing info 
    215 #             evt = ModelEventbox(model=self.model,  
    216 #                                         smearer=temp_smear,  
     216#             evt = ModelEventbox(model=self.model, 
     217#                                         smearer=temp_smear, 
    217218#                                         qmin=float(self.qmin_x), 
    218219#                                         uid=self.uid, 
    219 #                                      qmax=float(self.qmax_x))  
    220 #     
     220#                                      qmax=float(self.qmax_x)) 
     221# 
    221222#             self._manager._on_model_panel(evt=evt) 
    222223#             self.mbox_description.SetLabel("Model [%s]" % str(self.model.name)) 
    223224#             self.state.model = self.model.clone() 
    224225#             self.state.model.name = self.model.name 
    225 #  
    226 #              
     226# 
     227# 
    227228#         if event is not None: 
    228229#             ## post state to fit panel 
    229230#             new_event = PageInfoEvent(page = self) 
    230 #             wx.PostEvent(self.parent, new_event)  
     231#             wx.PostEvent(self.parent, new_event) 
    231232#             #update list of plugins if new plugin is available 
    232233#             if self.plugin_rbutton.GetValue(): 
    … …  
    243244#             self._draw_model() 
    244245#         self.SetupScrolling() 
    245 #         self.Show(True)    
    246 #          
     246#         self.Show(True) 
     247# 
    247248#     def _update_paramv_on_fit(self): 
    248249#         """ 
    … …  
    253254#         self.fitrange = True 
    254255#         is_modified = False 
    255 #  
     256# 
    256257#         if self.model is not None: 
    257258#             ##Check the values 
    … …  
    259260#             self._check_value_enter( self.fixed_param) 
    260261#             self._check_value_enter( self.parameters) 
    261 #  
    262 #             # If qmin and qmax have been modified, update qmin and qmax and  
     262# 
     263#             # If qmin and qmax have been modified, update qmin and qmax and 
    263264#              # Here we should check whether the boundaries have been modified. 
    264 #             # If qmin and qmax have been modified, update qmin and qmax and  
     265#             # If qmin and qmax have been modified, update qmin and qmax and 
    265266#             # set the is_modified flag to True 
    266267#             self.fitrange = self._validate_qrange(self.qmin, self.qmax) 
    … …  
    273274#                     self.qmax_x = tempmax 
    274275#                 if tempmax == tempmin: 
    275 #                     flag = False     
     276#                     flag = False 
    276277#                 #temp_smearer = None 
    277278#                 if self._is_2D(): 
    278 #                     # only 2D case set mask   
     279#                     # only 2D case set mask 
    279280#                     flag = self._validate_Npts() 
    280281#                     if not flag: 
    281282#                         return flag 
    282283#             else: flag = False 
    283 #         else:  
     284#         else: 
    284285#             flag = False 
    285 #  
    286 #         #For invalid q range, disable the mask editor and fit button, vs.     
     286# 
     287#         #For invalid q range, disable the mask editor and fit button, vs. 
    287288#         if not self.fitrange: 
    288289#             #self.btFit.Disable() 
    … …  
    293294#             if self._is_2D() and  self.data is not None: 
    294295#                 self.btEditMask.Enable(True) 
    295 #  
     296# 
    296297#         if not flag: 
    297298#             msg = "Cannot Plot or Fit :Must select a " 
    298299#             msg += " model or Fitting range is not valid!!!  " 
    299300#             wx.PostEvent(self.parent.parent, StatusEvent(status=msg)) 
    300 #          
     301# 
    301302#         self.save_current_state() 
    302 #     
    303 #         return flag   
     303# 
     304#         return flag 
    304305#     def save_current_state(self): 
    305306#         """ 
    306307#         Currently no save option implemented for batch page 
    307308#         """ 
    308 #         pass  
     309#         pass 
    309310#     def save_current_state_fit(self): 
    310311#         """ 
    … …  
    314315#     def set_data(self, data): 
    315316#         """ 
    316 #         reset the current data  
     317#         reset the current data 
    317318#         """ 
    318319#         #id = None 
    … …  
    340341#             self._set_save_flag(False) 
    341342#             self._set_preview_flag(True) 
    342 #    
     343# 
    343344#             self.formfactorbox.Enable() 
    344345#             self.structurebox.Enable() 
    … …  
    346347#             #set maximum range for x in linear scale 
    347348#             if not hasattr(self.data,"data"): #Display only for 1D data fit 
    348 #                 # Minimum value of data    
     349#                 # Minimum value of data 
    349350#                 data_min = min(self.data.x) 
    350 #                 # Maximum value of data   
     351#                 # Maximum value of data 
    351352#                 data_max = max(self.data.x) 
    352 #                 self.btEditMask.Disable()   
     353#                 self.btEditMask.Disable() 
    353354#                 self.EditMask_title.Disable() 
    354355#             else: 
    355 #                  
    356 #                 ## Minimum value of data  
     356# 
     357#                 ## Minimum value of data 
    357358#                 data_min = 0 
    358 #                 x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax))  
     359#                 x = max(math.fabs(self.data.xmin), math.fabs(self.data.xmax)) 
    359360#                 y = max(math.fabs(self.data.ymin), math.fabs(self.data.ymax)) 
    360 #                 ## Maximum value of data   
     361#                 ## Maximum value of data 
    361362#                 data_max = math.sqrt(x*x + y*y) 
    362 #                 self.btEditMask.Enable()   
    363 #                 self.EditMask_title.Enable()  
    364 #  
     363#                 self.btEditMask.Enable() 
     364#                 self.EditMask_title.Enable() 
     365# 
    365366#         self.dataSource.SetValue(data_name) 
    366367#         self.qmin_x = data_min 
    … …  
    375376#         self.state.qmin = self.qmin_x 
    376377#         self.state.qmax = self.qmax_x 
    377 #          
     378# 
    378379#         #update model plot with new data information 
    379380#         if flag: 
    … …  
    385386#                 self.enable2D = False 
    386387#                 self.model_view.SetLabel("1D Mode") 
    387 #                  
     388# 
    388389#             self.model_view.Disable() 
    389 #              
    390 #             wx.PostEvent(self._manager.parent,  
     390# 
     391#             wx.PostEvent(self._manager.parent, 
    391392#                              NewPlotEvent(group_id=group_id, 
    392393#                                                action="delete")) 
    393394#             #plot the current selected data 
    394 #             wx.PostEvent(self._manager.parent, NewPlotEvent(plot=self.data,  
     395#             wx.PostEvent(self._manager.parent, NewPlotEvent(plot=self.data, 
    395396#                                                     title=str(self.data.title))) 
    396397#             self._manager.store_data(uid=self.uid, data=data, 

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

    r959eb01 rba8d326  
    2929                 worktime=0.03, 
    3030                 reset_flag=False): 
    31         CalcThread.__init__(self, 
    32                  completefn, 
    33                  updatefn, 
    34                  yieldtime, 
    35                  worktime) 
     31        CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime) 
    3632        self.handler = handler 
    3733        self.fitter = fn 
    … …  
    9389            # Real code should not print, but this is an example... 
    9490            #print "keyboard exception" 
    95             #Stop on exception during fitting. Todo: need to put  
     91            #Stop on exception during fitting. Todo: need to put 
    9692            #some mssg and reset progress bar. 
    9793 
    … …  
    10096            if self.handler is not None: 
    10197                self.handler.stop(msg=msg) 
    102         except: 
     98        except:  # catch-all: show every exception which stops the thread 
    10399            import traceback 
    104100            if self.handler is not None: 

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

    r13374be r9706d88  
    1414from sasmodels.weights import MODELS as POLYDISPERSITY_MODELS 
    1515 
     16from sas.sascalc.fit.qsmearing import smear_selection 
     17 
    1618from sas.sasgui.guiframe.events import StatusEvent, NewPlotEvent, \ 
    1719    PlotQrangeEvent 
    … …  
    2325from sas.sasgui.perspectives.fitting.basepage import PageInfoEvent as \ 
    2426    PageInfoEvent 
    25 from sas.sascalc.data_util.qsmearing import smear_selection 
    2627from .basepage import ModelTextCtrl 
    2728 
    … …  
    11421143            self.model.name = "M" + str(self.index_model) 
    11431144 
    1144     def _on_select_model(self, event=None): 
     1145    def _on_select_model(self, event=None, keep_pars=False): 
    11451146        """ 
    11461147        call back for model selection 
    11471148        """ 
    11481149        self.Show(False) 
    1149         copy_flag = False 
    1150         is_poly_enabled = None 
    11511150        if event is not None: 
    1152             if (event.GetEventObject() == self.formfactorbox 
    1153                     and self.structurebox.GetLabel() != 'None')\ 
    1154                     or event.GetEventObject() == self.structurebox\ 
    1155                     or event.GetEventObject() == self.multifactorbox: 
    1156                 copy_flag = self.get_copy_params() 
    1157                 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 
     1164 
    11581165        try: 
    11591166            self._on_select_model_helper() 
    … …  
    11771184        try: 
    11781185            self.set_dispers_sizer() 
    1179         except: 
     1186        except Exception: 
    11801187            pass 
    11811188        self.state.enable_disp = self.enable_disp.GetValue() 
    … …  
    12381245            self.state.model.name = self.model.name 
    12391246 
     1247        # when select a model only from guictr/button 
     1248        if is_poly_enabled is not None: 
     1249            self.enable_disp.SetValue(is_poly_enabled) 
     1250            self.disable_disp.SetValue(not is_poly_enabled) 
     1251            self._set_dipers_Param(event=None) 
     1252            self.state.enable_disp = self.enable_disp.GetValue() 
     1253            self.state.disable_disp = self.disable_disp.GetValue() 
     1254 
     1255        # Keep the previous param values 
     1256        if saved_pars: 
     1257            self.get_paste_params(saved_pars) 
     1258 
    12401259        if event is not None: 
     1260            # update list of plugins if new plugin is available 
     1261            # mod_cat = self.categorybox.GetStringSelection() 
     1262            # if mod_cat == CUSTOM_MODEL: 
     1263            #     temp = self.parent.update_model_list() 
     1264            #     for v in self.parent.model_dictionary.values(): 
     1265            #         if v.id == self.model.id: 
     1266            #             self.model = v() 
     1267            #             break 
     1268            #     if temp: 
     1269            #         self.model_list_box = temp 
     1270            #         current_val = self.formfactorbox.GetLabel() 
     1271            #         pos = self.formfactorbox.GetSelection() 
     1272            #         self._show_combox_helper() 
     1273            #         self.formfactorbox.SetStringSelection(current_val) 
     1274            #         self.formfactorbox.SetValue(current_val) 
    12411275            # post state to fit panel 
    12421276            new_event = PageInfoEvent(page=self) 
    12431277            wx.PostEvent(self.parent, new_event) 
    1244             # update list of plugins if new plugin is available 
    1245             mod_cat = self.categorybox.GetStringSelection() 
    1246             if mod_cat == CUSTOM_MODEL: 
    1247                 temp_id = self.model.id 
    1248                 temp = self.parent.update_model_list() 
    1249                 for v in self.parent.model_dictionary.values(): 
    1250                     if v.id == temp_id: 
    1251                         self.model = v() 
    1252                         break 
    1253                 if temp: 
    1254                     self.model_list_box = temp 
    1255                     current_val = self.formfactorbox.GetLabel() 
    1256                     pos = self.formfactorbox.GetSelection() 
    1257                     self._show_combox_helper() 
    1258                     self.formfactorbox.SetSelection(pos) 
    1259                     self.formfactorbox.SetValue(current_val) 
    1260             # when select a model only from guictr/button 
    1261             if is_poly_enabled is not None: 
    1262                 self.enable_disp.SetValue(is_poly_enabled) 
    1263                 self.disable_disp.SetValue(not is_poly_enabled) 
    1264                 self._set_dipers_Param(event=None) 
    1265                 self.state.enable_disp = self.enable_disp.GetValue() 
    1266                 self.state.disable_disp = self.disable_disp.GetValue() 
    1267  
    1268             # Keep the previous param values 
    1269             if copy_flag: 
    1270                 self.get_paste_params(copy_flag) 
    12711278            wx.CallAfter(self._onDraw, None) 
    12721279 
    … …  
    17261733        ind = 0 
    17271734        while(ind < len(list)): 
    1728             for key, val in list.iteritems(): 
    1729                 if (val == ind): 
     1735            for key, val in list.items(): 
     1736                if val == ind: 
    17301737                    fun_box.Append(key, val) 
    17311738                    break 

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

    r13374be r69363c7  
    99from wx.aui import AuiNotebook as nb 
    1010 
     11from sas.sascalc.fit.models import ModelManager 
     12 
    1113from sas.sasgui.guiframe.panel_base import PanelBase 
    1214from sas.sasgui.guiframe.events import PanelOnFocusEvent, StatusEvent 
    1315from sas.sasgui.guiframe.dataFitting import check_data_validity 
    14 from sas.sasgui.perspectives.fitting.simfitpage import SimultaneousFitPage 
    15  
    16 import basepage 
    17 import models 
     16 
     17 
     18from . import basepage 
     19from .fitpage import FitPage 
     20from .simfitpage import SimultaneousFitPage 
     21from .batchfitpage import BatchFitPage 
     22from .fitting_widgets import BatchDataDialog 
     23 
    1824_BOX_WIDTH = 80 
    1925 
    … …  
    4652        self.event_owner = None 
    4753        # dictionary of miodel {model class name, model class} 
    48         self.menu_mng = models.ModelManager() 
     54        self.menu_mng = ModelManager() 
    4955        self.model_list_box = self.menu_mng.get_model_list() 
    5056        # pageClosedEvent = nb.EVT_FLATNOTEBOOK_PAGE_CLOSING 
    … …  
    114120        """ 
    115121        temp = self.menu_mng.update() 
    116         if len(temp): 
     122        if temp: 
    117123            self.model_list_box = temp 
    118124        return temp 
    … …  
    121127        """ 
    122128        """ 
    123         temp = self.menu_mng.plugins_reset() 
    124         if len(temp): 
    125             self.model_list_box = temp 
    126         return temp 
     129        self.model_list_box = self.menu_mng.plugins_reset() 
     130        return self.model_list_box 
    127131 
    128132    def get_page_by_id(self, uid): 
    … …  
    298302        self.model_list_box = dict 
    299303 
    300     def set_model_dict(self, m_dict): 
     304    def set_model_dictionary(self, model_dictionary): 
    301305        """ 
    302306        copy a dictionary of model name -> model object 
    303307 
    304         :param m_dict: dictionary linking model name -> model object 
     308        :param model_dictionary: dictionary linking model name -> model object 
    305309        """ 
    306310 
    … …  
    316320        Add the simultaneous fit page 
    317321        """ 
    318         from simfitpage import SimultaneousFitPage 
    319322        page_finder = self._manager.get_page_finder() 
    320323        if caption == "Const & Simul Fit": 
    … …  
    344347        """ 
    345348        if self.batch_on: 
    346             from batchfitpage import BatchFitPage 
    347349            panel = BatchFitPage(parent=self) 
    348350            self.batch_page_index += 1 
    … …  
    351353        else: 
    352354            # Increment index of fit page 
    353             from fitpage import FitPage 
    354355            panel = FitPage(parent=self) 
    355356            self.fit_page_index += 1 
    … …  
    359360        panel._set_save_flag(not panel.batch_on) 
    360361        panel.set_model_dictionary(self.model_dictionary) 
    361         panel.populate_box(model_dict=self.model_list_box) 
     362        panel.populate_box(model_list_box=self.model_list_box) 
    362363        panel.formfactor_combo_init() 
    363364        panel.set_manager(self._manager) 
    … …  
    445446        if data_1d_list and data_2d_list: 
    446447            # need to warning the user that this batch is a special case 
    447             from sas.sasgui.perspectives.fitting.fitting_widgets import \ 
    448                 BatchDataDialog 
    449448            dlg = BatchDataDialog(self) 
    450449            if dlg.ShowModal() == wx.ID_OK: 

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

    r959eb01 r251ef684  
    1414################################################################################ 
    1515import copy 
    16 from sas.sascalc.data_util.qsmearing import smear_selection 
    17  
    18 class FitProblemComponent(object): 
     16 
     17from sas.sascalc.fit.qsmearing import smear_selection 
     18 
     19class FitProblem(object): 
    1920    """ 
    20     Inferface containing information to store data, model, range of data, etc... 
    21     and retreive this information. This is an inferface 
    22     for a fitProblem i.e relationship between data and model. 
     21    Define the relationship between data and model, including range, weights, 
     22    etc. 
    2323    """ 
     24    def __init__(self): 
     25        """ 
     26        contains information about data and model to fit 
     27        """ 
     28        ## data used for fitting 
     29        self.fit_data = None 
     30        self.theory_data = None 
     31        self.residuals = None 
     32        # original data: should not be modified 
     33        self.original_data = None 
     34        ## the current model 
     35        self.model = None 
     36        ## if 1 this fit problem will be selected to fit , if 0 
     37        ## it will not be selected for fit 
     38        self.schedule = 0 
     39        ##list containing parameter name and value 
     40        self.list_param = [] 
     41        self.list_param2fit = [] 
     42        ## smear object to smear or not data1D 
     43        self.smearer_computed = False 
     44        self.smearer_enable = False 
     45        self.smearer_computer_value = None 
     46        ## fitting range 
     47        self.qmin = None 
     48        self.qmax = None 
     49        # fit weight 
     50        self.weight = None 
     51        self.result = None 
     52        self.fit_tab_caption = None 
     53        self.name_per_page = None 
     54 
    2455    def enable_smearing(self, flag=False): 
    2556        """ 
    … …  
    2758            flag is 0 ingore smear value. 
    2859        """ 
     60        self.smearer_enable = flag 
     61 
     62    def set_smearer(self, smearer): 
     63        """ 
     64        save reference of  smear object on fitdata 
     65 
     66        :param smear: smear object from DataLoader 
     67 
     68        """ 
     69        self.smearer_computer_value = smearer 
    2970 
    3071    def get_smearer(self): 
    … …  
    3273        return smear object 
    3374        """ 
     75        if not self.smearer_enable: 
     76            return None 
     77        if not self.smearer_computed: 
     78            #smeari_selection should be call only once per fitproblem 
     79            self.smearer_computer_value = smear_selection(self.fit_data, 
     80                                                          self.model) 
     81            self.smearer_computed = True 
     82        return self.smearer_computer_value 
     83 
    3484    def save_model_name(self, name): 
    3585        """ 
    3686        """ 
     87        self.name_per_page = name 
    3788 
    3889    def get_name(self): 
    3990        """ 
    4091        """ 
     92        return self.name_per_page 
    4193 
    4294    def set_model(self, model): 
    … …  
    4698        :param name: name created for model 
    4799        """ 
     100        self.model = model 
     101        self.smearer_computer_value = smear_selection(self.fit_data, 
     102                                                      self.model) 
     103        self.smearer_computed = True 
    48104 
    49105    def get_model(self): 
    … …  
    51107        :return: saved model 
    52108        """ 
     109        return self.model 
    53110 
    54111    def set_residuals(self, residuals): 
    … …  
    57114        :param data: data selected 
    58115        """ 
     116        self.residuals = residuals 
    59117 
    60118    def get_residuals(self): 
    … …  
    62120        :return: residuals 
    63121        """ 
     122        return self.residuals 
    64123 
    65124    def set_theory_data(self, data): 
    66125        """ 
    67126        save a copy of the data select to fit 
     127 
    68128        :param data: data selected 
    69         """ 
     129 
     130        """ 
     131        self.theory_data = copy.deepcopy(data) 
    70132 
    71133    def get_theory_data(self): 
    72134        """ 
    73         :return: list of data dList 
    74         """ 
     135        :return: theory generated with the current model and data of this class 
     136        """ 
     137        return self.theory_data 
    75138 
    76139    def set_fit_data(self, data): 
    77140        """ 
    78         Store of list of data and create  by create new fitproblem of each data 
    79         id, if there was existing information about model, this information 
    80         get copy to the new fitproblem 
     141        Store data associated with this class 
    81142        :param data: list of data selected 
    82143        """ 
     144        self.original_data = None 
     145        self.fit_data = None 
     146        # original data: should not be modified 
     147        self.original_data = data 
     148        # fit data: used for fit and can be modified for convenience 
     149        self.fit_data = copy.deepcopy(data) 
     150        self.smearer_computer_value = smear_selection(self.fit_data, self.model) 
     151        self.smearer_computed = True 
     152        self.result = None 
    83153 
    84154    def get_fit_data(self): 
    85155        """ 
    86         """ 
     156        :return: data associate with this class 
     157        """ 
     158        return self.fit_data 
     159 
     160    def get_origin_data(self): 
     161        """ 
     162        """ 
     163        return self.original_data 
     164 
     165    def set_weight(self, is2d, flag=None): 
     166        """ 
     167        Received flag and compute error on data. 
     168        :param flag: flag to transform error of data. 
     169        :param is2d: flag to distinguish 1D to 2D Data 
     170        """ 
     171        from sas.sasgui.perspectives.fitting.utils import get_weight 
     172        # send original data for weighting 
     173        self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag) 
     174        if is2d: 
     175            self.fit_data.err_data = self.weight 
     176        else: 
     177            self.fit_data.dy = self.weight 
     178 
     179    def get_weight(self): 
     180        """ 
     181        returns weight array 
     182        """ 
     183        return self.weight 
     184 
     185    def set_param2fit(self, list): 
     186        """ 
     187        Store param names to fit (checked) 
     188        :param list: list of the param names 
     189        """ 
     190        self.list_param2fit = list 
     191 
     192    def get_param2fit(self): 
     193        """ 
     194        return the list param names to fit 
     195        """ 
     196        return self.list_param2fit 
    87197 
    88198    def set_model_param(self, name, value=None): 
    … …  
    92202        :param value: value of that parameter 
    93203        """ 
    94  
    95     def set_param2fit(self, list): 
    96         """ 
    97         Store param names to fit (checked) 
    98         :param list: list of the param names 
    99         """ 
    100  
    101     def get_param2fit(self): 
    102         """ 
    103         return the list param names to fit 
    104         """ 
     204        self.list_param.append([name, value]) 
    105205 
    106206    def get_model_param(self): 
    … …  
    108208        return list of couple of parameter name and value 
    109209        """ 
     210        return self.list_param 
    110211 
    111212    def schedule_tofit(self, schedule=0): 
    … …  
    113214        set schedule to true to decide if this fit  must be performed 
    114215        """ 
     216        self.schedule = schedule 
    115217 
    116218    def get_scheduled(self): 
    … …  
    118220        return true or false if a problem as being schedule for fitting 
    119221        """ 
     222        return self.schedule 
    120223 
    121224    def set_range(self, qmin=None, qmax=None): 
    122225        """ 
    123226        set fitting range 
    124         """ 
     227        :param qmin: minimum value to consider for the fit range 
     228        :param qmax: maximum value to consider for the fit range 
     229        """ 
     230        self.qmin = qmin 
     231        self.qmax = qmax 
    125232 
    126233    def get_range(self): 
    127234        """ 
    128235        :return: fitting range 
    129         """ 
    130  
    131     def set_weight(self, flag=None): 
    132         """ 
    133         set fitting range 
    134         """ 
    135  
    136     def get_weight(self): 
    137         """ 
    138         get fitting weight 
    139         """ 
     236 
     237        """ 
     238        return self.qmin, self.qmax 
    140239 
    141240    def clear_model_param(self): 
    … …  
    143242        clear constraint info 
    144243        """ 
     244        self.list_param = [] 
    145245 
    146246    def set_fit_tab_caption(self, caption): 
    147247        """ 
    148         store the caption of the page associated with object 
    149         """ 
     248        """ 
     249        self.fit_tab_caption = str(caption) 
    150250 
    151251    def get_fit_tab_caption(self): 
    152252        """ 
    153         Return the caption of the page associated with object 
    154         """ 
     253        """ 
     254        return self.fit_tab_caption 
    155255 
    156256    def set_graph_id(self, id): 
    … …  
    158258        Set graph id (from data_group_id at the time the graph produced) 
    159259        """ 
     260        self.graph_id = id 
    160261 
    161262    def get_graph_id(self): 
    … …  
    163264        Get graph_id 
    164265        """ 
     266        return self.graph_id 
    165267 
    166268    def set_result(self, result): 
    167269        """ 
    168270        """ 
     271        self.result = result 
    169272 
    170273    def get_result(self): 
    … …  
    172275        get result 
    173276        """ 
    174  
    175  
    176 class FitProblemDictionary(FitProblemComponent, dict): 
     277        return self.result 
     278 
     279 
     280class FitProblemDictionary(dict): 
    177281    """ 
    178282    This module implements a dictionary of fitproblem objects 
    179283    """ 
    180284    def __init__(self): 
    181         FitProblemComponent.__init__(self) 
    182285        dict.__init__(self) 
    183286        ## the current model 
    … …  
    206309        self._smear_on = flag 
    207310        if fid is None: 
    208             for value in self.itervalues(): 
     311            for value in self.values(): 
    209312                value.enable_smearing(flag) 
    210         else: 
    211             if fid in self.iterkeys(): 
    212                 self[fid].enable_smearing(flag) 
     313        elif fid in self: 
     314            self[fid].enable_smearing(flag) 
    213315 
    214316    def set_smearer(self, smearer, fid=None): 
    … …  
    218320        """ 
    219321        if fid is None: 
    220             for value in self.itervalues(): 
     322            for value in self.values(): 
    221323                value.set_smearer(smearer) 
    222         else: 
    223             if fid in self.iterkeys(): 
    224                 self[fid].set_smearer(smearer) 
     324        elif fid in self: 
     325            self[fid].set_smearer(smearer) 
    225326 
    226327    def get_smearer(self, fid=None): 
    … …  
    228329        return smear object 
    229330        """ 
    230         if fid in self.iterkeys(): 
     331        if fid in self: 
    231332            return self[fid].get_smearer() 
    232333 
    … …  
    235336        """ 
    236337        if fid is None: 
    237             for value in self.itervalues(): 
     338            for value in self.values(): 
    238339                value.save_model_name(name) 
    239         else: 
    240             if fid in self.iterkeys(): 
    241                 self[fid].save_model_name(name) 
     340        elif fid in self: 
     341            self[fid].save_model_name(name) 
    242342 
    243343    def get_name(self, fid=None): 
    … …  
    246346        result = [] 
    247347        if fid is None: 
    248             for value in self.itervalues(): 
     348            for value in self.values(): 
    249349                result.append(value.get_name()) 
    250         else: 
    251             if fid in self.iterkeys(): 
    252                 result.append(self[fid].get_name()) 
     350        elif fid in self: 
     351            result.append(self[fid].get_name()) 
    253352        return result 
    254353 
    … …  
    261360        self.model = model 
    262361        if fid is None: 
    263             for value in self.itervalues(): 
     362            for value in self.values(): 
    264363                value.set_model(self.model) 
    265         else: 
    266             if fid in self.iterkeys(): 
    267                 self[fid].set_model(self.model) 
     364        elif fid in self: 
     365            self[fid].set_model(self.model) 
    268366 
    269367    def get_model(self, fid): 
    … …  
    271369        :return: saved model 
    272370        """ 
    273         if fid in self.iterkeys(): 
     371        if fid in self: 
    274372            return self[fid].get_model() 
    275373 
    … …  
    291389        :param data: data selected 
    292390        """ 
    293         if fid in self.iterkeys(): 
     391        if fid in self: 
    294392            self[fid].set_residuals(residuals) 
    295393 
    … …  
    298396        :return: residuals 
    299397        """ 
    300         if fid in self.iterkeys(): 
     398        if fid in self: 
    301399            return self[fid].get_residuals() 
    302400 
    … …  
    306404        :param data: data selected 
    307405        """ 
    308         if fid in self.iterkeys(): 
     406        if fid in self: 
    309407            self[fid].set_theory_data(data) 
    310408 
    … …  
    313411        :return: list of data dList 
    314412        """ 
    315         if fid in self.iterkeys(): 
     413        if fid in self: 
    316414            return self[fid].get_theory_data() 
    317415 
    … …  
    322420        :note: only data changes in the fit problem 
    323421        """ 
    324         if data.id not in self.iterkeys(): 
     422        if data.id not in self: 
    325423            self[data.id] = FitProblem() 
    326424        self[data.id].set_fit_data(data) 
    … …  
    336434            data = [] 
    337435        for d in data: 
    338             if (d is not None): 
    339                 if (d.id not in self.iterkeys()): 
     436            if d is not None: 
     437                if d.id not in self: 
    340438                    self[d.id] = FitProblem() 
    341439                self[d.id].set_fit_data(d) 
    … …  
    348446        :param fid: key representing a fitproblem, usually extract from data id 
    349447        """ 
    350         if fid in self.iterkeys(): 
     448        if fid in self: 
    351449            return self[fid].get_fit_data() 
    352450 
    … …  
    358456        """ 
    359457        if fid is None: 
    360             for value in self.itervalues(): 
     458            for value in self.values(): 
    361459                value.set_model_param(name, value) 
    362         else: 
    363             if fid in self.iterkeys(): 
    364                 self[fid].set_model_param(name, value) 
     460        elif fid in self: 
     461            self[fid].set_model_param(name, value) 
    365462 
    366463    def get_model_param(self, fid): 
    … …  
    368465        return list of couple of parameter name and value 
    369466        """ 
    370         if fid in self.iterkeys(): 
     467        if fid in self: 
    371468            return self[fid].get_model_param() 
    372469 
    … …  
    389486        """ 
    390487        self.scheduled = schedule 
    391         for value in self.itervalues(): 
     488        for value in self.values(): 
    392489            value.schedule_tofit(schedule) 
    393490 
    … …  
    405502        self.qmax = qmax 
    406503        if fid is None: 
    407             for value in self.itervalues(): 
     504            for value in self.values(): 
    408505                value.set_range(self.qmin, self.qmax) 
    409         else: 
    410             if fid in self.iterkeys(): 
    411                 self[fid].value.set_range(self.qmin, self.qmax) 
     506        elif fid in self: 
     507            self[fid].value.set_range(self.qmin, self.qmax) 
    412508 
    413509    def get_range(self, fid): 
    … …  
    415511        :return: fitting range 
    416512        """ 
    417         if fid in self.iterkeys(): 
     513        if fid in self: 
    418514            return self[fid].get_range() 
    419515 
    … …  
    423519        """ 
    424520        if fid is None: 
    425             for value in self.itervalues(): 
     521            for value in self.values(): 
    426522                value.set_weight(flag=flag, is2d=is2d) 
    427         else: 
    428             if fid in self.iterkeys(): 
    429                 self[fid].set_weight(flag=flag, is2d=is2d) 
     523        elif fid in self: 
     524            self[fid].set_weight(flag=flag, is2d=is2d) 
    430525 
    431526    def get_weight(self, fid=None): 
    … …  
    433528        return fit weight 
    434529        """ 
    435         if fid in self.iterkeys(): 
     530        if fid in self: 
    436531            return self[fid].get_weight() 
    437532 
    … …  
    441536        """ 
    442537        if fid is None: 
    443             for value in self.itervalues(): 
     538            for value in self.values(): 
    444539                value.clear_model_param() 
    445         else: 
    446             if fid in self.iterkeys(): 
    447                 self[fid].clear_model_param() 
     540        elif fid in self: 
     541            self[fid].clear_model_param() 
    448542 
    449543    def get_fit_problem(self): 
    … …  
    451545        return fitproblem contained in this dictionary 
    452546        """ 
    453         return self.itervalues() 
     547        return self.values() 
    454548 
    455549    def set_result(self, result, fid): 
    456550        """ 
    457551        """ 
    458         if fid in self.iterkeys(): 
     552        if fid in self: 
    459553            self[fid].set_result(result) 
    460554 
    … …  
    470564        get result 
    471565        """ 
    472         if fid in self.iterkeys(): 
     566        if fid in self: 
    473567            return self[fid].get_result() 
    474568 
    … …  
    490584        """ 
    491585        return self.graph_id 
    492  
    493  
    494 class FitProblem(FitProblemComponent): 
    495     """ 
    496     FitProblem class allows to link a model with the new name created in _on_model, 
    497     a name theory created with that model  and the data fitted with the model. 
    498     FitProblem is mostly used  as value of the dictionary by fitting module. 
    499     """ 
    500     def __init__(self): 
    501         FitProblemComponent.__init__(self) 
    502         """ 
    503         contains information about data and model to fit 
    504         """ 
    505         ## data used for fitting 
    506         self.fit_data = None 
    507         self.theory_data = None 
    508         self.residuals = None 
    509         # original data: should not be modified 
    510         self.original_data = None 
    511         ## the current model 
    512         self.model = None 
    513         ## if 1 this fit problem will be selected to fit , if 0 
    514         ## it will not be selected for fit 
    515         self.schedule = 0 
    516         ##list containing parameter name and value 
    517         self.list_param = [] 
    518         ## smear object to smear or not data1D 
    519         self.smearer_computed = False 
    520         self.smearer_enable = False 
    521         self.smearer_computer_value = None 
    522         ## fitting range 
    523         self.qmin = None 
    524         self.qmax = None 
    525         # fit weight 
    526         self.weight = None 
    527         self.result = None 
    528  
    529     def enable_smearing(self, flag=False): 
    530         """ 
    531         :param flag: bool.When flag is 1 get the computer smear value. When 
    532             flag is 0 ingore smear value. 
    533         """ 
    534         self.smearer_enable = flag 
    535  
    536     def set_smearer(self, smearer): 
    537         """ 
    538         save reference of  smear object on fitdata 
    539  
    540         :param smear: smear object from DataLoader 
    541  
    542         """ 
    543         self.smearer_computer_value = smearer 
    544  
    545     def get_smearer(self): 
    546         """ 
    547         return smear object 
    548         """ 
    549         if not self.smearer_enable: 
    550             return None 
    551         if not self.smearer_computed: 
    552             #smeari_selection should be call only once per fitproblem 
    553             self.smearer_computer_value = smear_selection(self.fit_data, 
    554                                                            self.model) 
    555             self.smearer_computed = True 
    556         return self.smearer_computer_value 
    557  
    558     def save_model_name(self, name): 
    559         """ 
    560         """ 
    561         self.name_per_page = name 
    562  
    563     def get_name(self): 
    564         """ 
    565         """ 
    566         return self.name_per_page 
    567  
    568     def set_model(self, model): 
    569         """ 
    570         associates each model with its new created name 
    571         :param model: model selected 
    572         :param name: name created for model 
    573         """ 
    574         self.model = model 
    575         self.smearer_computer_value = smear_selection(self.fit_data, 
    576                                                            self.model) 
    577         self.smearer_computed = True 
    578  
    579     def get_model(self): 
    580         """ 
    581         :return: saved model 
    582         """ 
    583         return self.model 
    584  
    585     def set_residuals(self, residuals): 
    586         """ 
    587         save a copy of residual 
    588         :param data: data selected 
    589         """ 
    590         self.residuals = residuals 
    591  
    592     def get_residuals(self): 
    593         """ 
    594         :return: residuals 
    595         """ 
    596         return self.residuals 
    597  
    598     def set_theory_data(self, data): 
    599         """ 
    600         save a copy of the data select to fit 
    601  
    602         :param data: data selected 
    603  
    604         """ 
    605         self.theory_data = copy.deepcopy(data) 
    606  
    607     def get_theory_data(self): 
    608         """ 
    609         :return: theory generated with the current model and data of this class 
    610         """ 
    611         return self.theory_data 
    612  
    613     def set_fit_data(self, data): 
    614         """ 
    615         Store data associated with this class 
    616         :param data: list of data selected 
    617         """ 
    618         self.original_data = None 
    619         self.fit_data = None 
    620         # original data: should not be modified 
    621         self.original_data = data 
    622         # fit data: used for fit and can be modified for convenience 
    623         self.fit_data = copy.deepcopy(data) 
    624         self.smearer_computer_value = smear_selection(self.fit_data, 
    625                                                            self.model) 
    626         self.smearer_computed = True 
    627         self.result = None 
    628  
    629     def get_fit_data(self): 
    630         """ 
    631         :return: data associate with this class 
    632         """ 
    633         return self.fit_data 
    634  
    635     def get_origin_data(self): 
    636         """ 
    637         """ 
    638         return self.original_data 
    639  
    640     def set_weight(self, is2d, flag=None): 
    641         """ 
    642         Received flag and compute error on data. 
    643         :param flag: flag to transform error of data. 
    644         :param is2d: flag to distinguish 1D to 2D Data 
    645         """ 
    646         from sas.sasgui.perspectives.fitting.utils import get_weight 
    647         # send original data for weighting 
    648         self.weight = get_weight(data=self.original_data, is2d=is2d, flag=flag) 
    649         if is2d: 
    650             self.fit_data.err_data = self.weight 
    651         else: 
    652             self.fit_data.dy = self.weight 
    653  
    654     def get_weight(self): 
    655         """ 
    656         returns weight array 
    657         """ 
    658         return self.weight 
    659  
    660     def set_param2fit(self, list): 
    661         """ 
    662         Store param names to fit (checked) 
    663         :param list: list of the param names 
    664         """ 
    665         self.list_param2fit = list 
    666  
    667     def get_param2fit(self): 
    668         """ 
    669         return the list param names to fit 
    670         """ 
    671         return self.list_param2fit 
    672  
    673     def set_model_param(self, name, value=None): 
    674         """ 
    675         Store the name and value of a parameter of this fitproblem's model 
    676         :param name: name of the given parameter 
    677         :param value: value of that parameter 
    678         """ 
    679         self.list_param.append([name, value]) 
    680  
    681     def get_model_param(self): 
    682         """ 
    683         return list of couple of parameter name and value 
    684         """ 
    685         return self.list_param 
    686  
    687     def schedule_tofit(self, schedule=0): 
    688         """ 
    689         set schedule to true to decide if this fit  must be performed 
    690         """ 
    691         self.schedule = schedule 
    692  
    693     def get_scheduled(self): 
    694         """ 
    695         return true or false if a problem as being schedule for fitting 
    696         """ 
    697         return self.schedule 
    698  
    699     def set_range(self, qmin=None, qmax=None): 
    700         """ 
    701         set fitting range 
    702         :param qmin: minimum value to consider for the fit range 
    703         :param qmax: maximum value to consider for the fit range 
    704         """ 
    705         self.qmin = qmin 
    706         self.qmax = qmax 
    707  
    708     def get_range(self): 
    709         """ 
    710         :return: fitting range 
    711  
    712         """ 
    713         return self.qmin, self.qmax 
    714  
    715     def clear_model_param(self): 
    716         """ 
    717         clear constraint info 
    718         """ 
    719         self.list_param = [] 
    720  
    721     def set_fit_tab_caption(self, caption): 
    722         """ 
    723         """ 
    724         self.fit_tab_caption = str(caption) 
    725  
    726     def get_fit_tab_caption(self): 
    727         """ 
    728         """ 
    729         return self.fit_tab_caption 
    730  
    731     def set_graph_id(self, id): 
    732         """ 
    733         Set graph id (from data_group_id at the time the graph produced) 
    734         """ 
    735         self.graph_id = id 
    736  
    737     def get_graph_id(self): 
    738         """ 
    739         Get graph_id 
    740         """ 
    741         return self.graph_id 
    742  
    743     def set_result(self, result): 
    744         """ 
    745         """ 
    746         self.result = result 
    747  
    748     def get_result(self): 
    749         """ 
    750         get result 
    751         """ 
    752         return self.result 

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

    r66acafe r9706d88  
    2323import traceback 
    2424 
     25import bumps.options 
     26from bumps.gui.fit_dialog import show_fit_config 
     27try: 
     28    from bumps.gui.fit_dialog import EVT_FITTER_CHANGED 
     29except ImportError: 
     30    # CRUFT: bumps 0.7.5.8 and below 
     31    EVT_FITTER_CHANGED = None  # type: wx.PyCommandEvent 
     32 
    2533from sas.sascalc.dataloader.loader import Loader 
     34from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit 
     35from sas.sascalc.fit.pagestate import Reader, PageState, SimFitPageState 
     36from sas.sascalc.fit import models 
     37 
    2638from sas.sasgui.guiframe.dataFitting import Data2D 
    2739from sas.sasgui.guiframe.dataFitting import Data1D 
    … …  
    3446from sas.sasgui.guiframe.plugin_base import PluginBase 
    3547from sas.sasgui.guiframe.data_processor import BatchCell 
    36 from sas.sascalc.fit.BumpsFitting import BumpsFit as Fit 
    37 from sas.sasgui.perspectives.fitting.console import ConsoleUpdate 
    38 from sas.sasgui.perspectives.fitting.fitproblem import FitProblemDictionary 
    39 from sas.sasgui.perspectives.fitting.fitpanel import FitPanel 
    40 from sas.sasgui.perspectives.fitting.resultpanel import ResultPanel, PlotResultEvent 
    41  
    42 from sas.sasgui.perspectives.fitting.fit_thread import FitThread 
    43 from sas.sasgui.perspectives.fitting.pagestate import Reader 
    44 from sas.sasgui.perspectives.fitting.fitpage import Chi2UpdateEvent 
     48from sas.sasgui.guiframe.gui_manager import MDIFrame 
     49from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     50 
    4551from sas.sasgui.perspectives.calculator.model_editor import TextDialog 
    4652from sas.sasgui.perspectives.calculator.model_editor import EditorWindow 
    47 from sas.sasgui.guiframe.gui_manager import MDIFrame 
    48 from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
    49 from sas.sasgui.perspectives.fitting.gpu_options import GpuOptions 
    50  
    51 from . import models 
     53from sas.sasgui.perspectives.calculator.pyconsole import PyConsole 
     54 
     55from .fitting_widgets import DataDialog 
     56from .fit_thread import FitThread 
     57from .fitpage import Chi2UpdateEvent 
     58from .console import ConsoleUpdate 
     59from .fitproblem import FitProblemDictionary 
     60from .fitpanel import FitPanel 
     61from .model_thread import Calc1D, Calc2D 
     62from .resultpanel import ResultPanel, PlotResultEvent 
     63from .gpu_options import GpuOptions 
    5264 
    5365logger = logging.getLogger(__name__) 
    … …  
    6375    ON_MAC = True 
    6476 
    65 import bumps.options 
    66 from bumps.gui.fit_dialog import show_fit_config 
    67 try: 
    68     from bumps.gui.fit_dialog import EVT_FITTER_CHANGED 
    69 except ImportError: 
    70     # CRUFT: bumps 0.7.5.8 and below 
    71     EVT_FITTER_CHANGED = None  # type: wx.PyCommandEvent 
    7277 
    7378class Plugin(PluginBase): 
    … …  
    240245        event_id = event.GetId() 
    241246        label = self.edit_menu.GetLabel(event_id) 
    242         from sas.sasgui.perspectives.calculator.pyconsole import PyConsole 
    243247        filename = os.path.join(models.find_plugins_dir(), label) 
    244248        frame = PyConsole(parent=self.parent, manager=self, 
    … …  
    290294                        break 
    291295        except Exception: 
    292             import traceback; traceback.print_exc() 
     296            traceback.print_exc() 
    293297            msg = 'Delete Error: \nCould not delete the file; Check if in use.' 
    294298            wx.MessageBox(msg, 'Error') 
    … …  
    300304        event_id = event.GetId() 
    301305        model_manager = models.ModelManager() 
    302         model_list = model_manager.get_model_name_list() 
     306        model_list = model_manager.composable_models() 
    303307        plug_dir = models.find_plugins_dir() 
    304308        textdial = TextDialog(None, self, wx.ID_ANY, 'Easy Sum/Multi(p1, p2) Editor', 
    … …  
    340344            self.set_edit_menu_helper(self.parent, self.edit_custom_model) 
    341345            self.set_edit_menu_helper(self.parent, self.delete_custom_model) 
    342             temp = self.fit_panel.reset_pmodel_list() 
    343             if temp: 
    344                 # Set the new plugin model list for all fit pages 
    345                 for uid, page in self.fit_panel.opened_pages.iteritems(): 
    346                     if hasattr(page, "formfactorbox"): 
    347                         page.model_list_box = temp 
    348                         current_val = page.formfactorbox.GetLabel() 
    349                         #if page.plugin_rbutton.GetValue(): 
    350                         mod_cat = page.categorybox.GetStringSelection() 
    351                         if mod_cat == custom_model: 
    352                             #pos = page.formfactorbox.GetSelection() 
    353                             page._show_combox_helper() 
    354                             new_val = page.formfactorbox.GetLabel() 
    355                             if current_val != new_val and new_val != '': 
    356                                 page.formfactorbox.SetLabel(new_val) 
    357                             else: 
    358                                 page.formfactorbox.SetLabel(current_val) 
    359                         if hasattr(page, 'structurebox'): 
    360                             selected_name = page.structurebox.GetStringSelection() 
    361  
    362                             page.structurebox.Clear() 
    363                             page.initialize_combox() 
    364  
    365                             index = page.structurebox.FindString(selected_name) 
    366                             if index == -1: 
    367                                 index = 0 
    368                             page.structurebox.SetSelection(index) 
    369                             page._on_select_model() 
    370         except: 
     346            new_pmodel_list = self.fit_panel.reset_pmodel_list() 
     347            if not new_pmodel_list: 
     348                return 
     349            # Set the new plugin model list for all fit pages 
     350            for uid, page in self.fit_panel.opened_pages.iteritems(): 
     351                if hasattr(page, "formfactorbox"): 
     352                    page.model_list_box = new_pmodel_list 
     353                    mod_cat = page.categorybox.GetStringSelection() 
     354                    if mod_cat == custom_model: 
     355                        box = page.formfactorbox 
     356                        model_name = box.GetValue() 
     357                        model = (box.GetClientData(box.GetCurrentSelection()) 
     358                                 if model_name else None) 
     359                        page._show_combox_helper() 
     360                        new_index = box.FindString(model_name) 
     361                        new_model = (box.GetClientData(new_index) 
     362                                     if new_index >= 0 else None) 
     363                        if new_index >= 0: 
     364                            box.SetStringSelection(model_name) 
     365                        else: 
     366                            box.SetStringSelection('') 
     367                        if model and new_model != model: 
     368                            page._on_select_model(keep_pars=True) 
     369                    if hasattr(page, "structurebox"): 
     370                        selected_name = page.structurebox.GetStringSelection() 
     371 
     372                        page.structurebox.Clear() 
     373                        page.initialize_combox() 
     374 
     375                        index = page.structurebox.FindString(selected_name) 
     376                        if index == -1: 
     377                            index = 0 
     378                        page.structurebox.SetSelection(index) 
     379                        page._on_select_model() 
     380        except Exception: 
    371381            logger.error("update_custom_combo: %s", sys.exc_value) 
    372382 
    … …  
    378388        #new_model_menu = wx.Menu() 
    379389        self.edit_model_menu.Append(wx_id, 'New Plugin Model', 
    380                                    'Add a new model function') 
     390                                    'Add a new model function') 
    381391        wx.EVT_MENU(owner, wx_id, self.make_new_model) 
    382392 
    … …  
    575585        else: 
    576586            if len(data_list) > MAX_NBR_DATA: 
    577                 from fitting_widgets import DataDialog 
    578587                dlg = DataDialog(data_list=data_list, nb_data=MAX_NBR_DATA) 
    579588                if dlg.ShowModal() == wx.ID_OK: 
    … …  
    620629        : param datainfo: data 
    621630        """ 
    622         from pagestate import PageState 
    623         from simfitpage import SimFitPageState 
    624631        if isinstance(state, PageState): 
    625632            state = state.clone() 
    626633            self.temp_state.append(state) 
    627634        elif isinstance(state, SimFitPageState): 
    628             state.load_from_save_state(self) 
     635            if self.fit_panel.sim_page is None: 
     636                self.fit_panel.add_sim_page() 
     637            self.fit_panel.sim_page.load_from_save_state(state) 
    629638        else: 
    630639            self.temp_state = [] 
    … …  
    661670                self.parent.add_data(data_list={data.id: data}) 
    662671                wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
    663                                         title=data.title)) 
     672                             title=data.title)) 
    664673                #need to be fix later make sure we are sendind guiframe.data 
    665674                #to panel 
    … …  
    672681                self.parent.add_data(data_list={data.id: data}) 
    673682                wx.PostEvent(self.parent, NewPlotEvent(plot=data, 
    674                                         title=data.title)) 
     683                             title=data.title)) 
    675684                page = self.add_fit_page([data]) 
    676685                caption = page.window_caption 
    677686                self.store_data(uid=page.uid, data_list=page.get_data_list(), 
    678                         caption=caption) 
     687                                caption=caption) 
    679688                self.mypanels.append(page) 
    680689 
    … …  
    793802        """ 
    794803        if item.find(".") >= 0: 
    795             param_names = re.split("\.", item) 
     804            param_names = re.split(r"\.", item) 
    796805            model_name = param_names[0] 
    797806            ##Assume max len is 3; eg., M0.radius.width 
    … …  
    896905 
    897906            self.draw_model(model=model, data=data, page_id=uid, smearer=smear, 
    898                 enable1D=enable1D, enable2D=enable2D, 
    899                 qmin=qmin, qmax=qmax, weight=weight) 
     907                            enable1D=enable1D, enable2D=enable2D, 
     908                            qmin=qmin, qmax=qmax, weight=weight) 
    900909 
    901910    def draw_model(self, model, page_id, data=None, smearer=None, 
    … …  
    940949            ## draw model 2D with no initial data 
    941950            self._draw_model2D(model=model, 
    942                                 page_id=page_id, 
    943                                 data=data, 
    944                                 enable2D=enable2D, 
    945                                 smearer=smearer, 
    946                                 qmin=qmin, 
    947                                 qmax=qmax, 
    948                                 fid=fid, 
    949                                 weight=weight, 
    950                                 state=state, 
    951                                 toggle_mode_on=toggle_mode_on, 
    952                                 update_chisqr=update_chisqr, 
    953                                 source=source) 
     951                               page_id=page_id, 
     952                               data=data, 
     953                               enable2D=enable2D, 
     954                               smearer=smearer, 
     955                               qmin=qmin, 
     956                               qmax=qmax, 
     957                               fid=fid, 
     958                               weight=weight, 
     959                               state=state, 
     960                               toggle_mode_on=toggle_mode_on, 
     961                               update_chisqr=update_chisqr, 
     962                               source=source) 
    954963 
    955964    def onFit(self, uid): 
    … …  
    960969        :param uid: id related to the panel currently calling this fit function. 
    961970        """ 
    962         if uid is None: raise RuntimeError("no page to fit") # Should never happen 
     971        if uid is None: 
     972            raise RuntimeError("no page to fit") # Should never happen 
    963973 
    964974        sim_page_uid = getattr(self.sim_page, 'uid', None) 
    … …  
    9941004                    page = self.fit_panel.get_page_by_id(page_id) 
    9951005                    self.set_fit_weight(uid=page.uid, 
    996                                      flag=page.get_weight_flag(), 
    997                                      is2d=page._is_2D()) 
     1006                                        flag=page.get_weight_flag(), 
     1007                                        is2d=page._is_2D()) 
    9981008                    if not page.param_toFit: 
    9991009                        msg = "No fitting parameters for %s" % page.window_caption 
    … …  
    10191029                            fitter = sim_fitter 
    10201030                        self._add_problem_to_fit(fitproblem=fitproblem, 
    1021                                              pars=pars, 
    1022                                              fitter=fitter, 
    1023                                              fit_id=fit_id) 
     1031                                                 pars=pars, 
     1032                                                 fitter=fitter, 
     1033                                                 fit_id=fit_id) 
    10241034                        fit_id += 1 
    10251035                    list_page_id.append(page_id) 
    … …  
    10681078            ## Perform more than 1 fit at the time 
    10691079            calc_fit = FitThread(handler=handler, 
    1070                                     fn=fitter_list, 
    1071                                     batch_inputs=batch_inputs, 
    1072                                     batch_outputs=batch_outputs, 
    1073                                     page_id=list_page_id, 
    1074                                     updatefn=handler.update_fit, 
    1075                                     completefn=self._fit_completed) 
     1080                                 fn=fitter_list, 
     1081                                 batch_inputs=batch_inputs, 
     1082                                 batch_outputs=batch_outputs, 
     1083                                 page_id=list_page_id, 
     1084                                 updatefn=handler.update_fit, 
     1085                                 completefn=self._fit_completed) 
    10761086        #self.fit_thread_list[current_page_id] = calc_fit 
    10771087        self.fit_thread_list[uid] = calc_fit 
    … …  
    11341144                evt = StatusEvent(status=msg, info="warning") 
    11351145                wx.PostEvent(self.parent, evt) 
    1136         except: 
     1146        except Exception: 
    11371147            msg = "Creating Fit page: %s" % sys.exc_value 
    11381148            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    … …  
    11581168                    group_id = str(page.uid) + " Model1D" 
    11591169                    wx.PostEvent(self.parent, 
    1160                              NewPlotEvent(group_id=group_id, 
    1161                                                action="delete")) 
     1170                                 NewPlotEvent(group_id=group_id, 
     1171                                              action="delete")) 
    11621172                    self.parent.update_data(prev_data=theory_data, 
    1163                                              new_data=data) 
     1173                                            new_data=data) 
    11641174            else: 
    11651175                if theory_data is not None: 
    … …  
    11671177                    data.group_id = theory_data.group_id 
    11681178                    wx.PostEvent(self.parent, 
    1169                              NewPlotEvent(group_id=group_id, 
    1170                                                action="delete")) 
     1179                                 NewPlotEvent(group_id=group_id, 
     1180                                              action="delete")) 
    11711181                    self.parent.update_data(prev_data=theory_data, 
    1172                                              new_data=data) 
     1182                                            new_data=data) 
    11731183        self.store_data(uid=page.uid, data_list=page.get_data_list(), 
    11741184                        caption=page.window_caption) 
    … …  
    14791489        if "Data" not in batch_outputs.keys(): 
    14801490            batch_outputs["Data"] = [] 
    1481         from sas.sasgui.guiframe.data_processor import BatchCell 
    14821491        cell = BatchCell() 
    14831492        cell.label = data.name 
    … …  
    15791588                    except KeyboardInterrupt: 
    15801589                        fit_msg += "\nSingular point: Fitting stopped." 
    1581                     except: 
     1590                    except Exception: 
    15821591                        fit_msg += "\nSingular point: Fitting error occurred." 
    15831592                if fit_msg: 
    1584                    evt = StatusEvent(status=fit_msg, info="warning", type="stop") 
    1585                    wx.PostEvent(self.parent, evt) 
    1586  
    1587         except: 
     1593                    evt = StatusEvent(status=fit_msg, info="warning", type="stop") 
     1594                    wx.PostEvent(self.parent, evt) 
     1595 
     1596        except Exception: 
    15881597            msg = ("Fit completed but the following error occurred: %s" 
    15891598                   % sys.exc_value) 
    1590             #import traceback; msg = "\n".join((traceback.format_exc(), msg)) 
     1599            #msg = "\n".join((traceback.format_exc(), msg)) 
    15911600            evt = StatusEvent(status=msg, info="warning", type="stop") 
    15921601            wx.PostEvent(self.parent, evt) 
    … …  
    17431752                                                  fid=data.id) 
    17441753        self.parent.update_theory(data_id=data.id, theory=new_plot, 
    1745                                    state=state) 
     1754                                  state=state) 
    17461755        return new_plot 
    17471756 
    … …  
    17671776        # Create the new theories 
    17681777        if unsmeared_model is not None: 
    1769             unsmeared_model_plot = self.create_theory_1D(x, unsmeared_model,  
     1778            unsmeared_model_plot = self.create_theory_1D(x, unsmeared_model, 
    17701779                                  page_id, model, data, state, 
    17711780                                  data_description=model.name + " unsmeared", 
    … …  
    17741783 
    17751784            if unsmeared_data is not None and unsmeared_error is not None: 
    1776                 unsmeared_data_plot = self.create_theory_1D(x, unsmeared_data,  
     1785                unsmeared_data_plot = self.create_theory_1D(x, unsmeared_data, 
    17771786                                      page_id, model, data, state, 
    17781787                                      data_description="Data unsmeared", 
    … …  
    17921801            plots_to_update.append(pq_plot) 
    17931802        # Update the P(Q), S(Q) and unsmeared theory plots if they exist 
    1794         wx.PostEvent(self.parent, NewPlotEvent(plots=plots_to_update,  
     1803        wx.PostEvent(self.parent, NewPlotEvent(plots=plots_to_update, 
    17951804                                              action='update')) 
    17961805 
    … …  
    18081817 
    18091818        self.page_finder[page_id].set_theory_data(data=new_plot, 
    1810                                                       fid=data.id) 
     1819                                                  fid=data.id) 
    18111820        if toggle_mode_on: 
    18121821            wx.PostEvent(self.parent, 
    18131822                         NewPlotEvent(group_id=str(page_id) + " Model2D", 
    1814                                           action="Hide")) 
     1823                                      action="Hide")) 
    18151824        else: 
    18161825            if update_chisqr: 
    1817                 wx.PostEvent(current_pg, 
    1818                              Chi2UpdateEvent(output=self._cal_chisqr( 
    1819                                                                 data=data, 
    1820                                                                 fid=fid, 
    1821                                                                 weight=weight, 
    1822                                                                 page_id=page_id, 
    1823                                                                 index=index))) 
     1826                output = self._cal_chisqr(data=data, 
     1827                                          fid=fid, 
     1828                                          weight=weight, 
     1829                                          page_id=page_id, 
     1830                                          index=index) 
     1831                wx.PostEvent(current_pg, Chi2UpdateEvent(output=output)) 
    18241832            else: 
    18251833                self._plot_residuals(page_id=page_id, data=data, fid=fid, 
    … …  
    18291837            logger.error("Using the present parameters the model does not return any finite value. ") 
    18301838            msg = "Computing Error: Model did not return any finite value." 
    1831             wx.PostEvent(self.parent, StatusEvent(status = msg, info="error")) 
     1839            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    18321840        else: 
    18331841            msg = "Computation  completed!" 
    … …  
    18541862 
    18551863    def _complete2D(self, image, data, model, page_id, elapsed, index, qmin, 
    1856                 qmax, fid=None, weight=None, toggle_mode_on=False, state=None, 
    1857                      update_chisqr=True, source='model', plot_result=True): 
     1864                    qmax, fid=None, weight=None, toggle_mode_on=False, state=None, 
     1865                    update_chisqr=True, source='model', plot_result=True): 
    18581866        """ 
    18591867        Complete get the result of modelthread and create model 2D 
    … …  
    18961904                                                  fid=data.id) 
    18971905        self.parent.update_theory(data_id=data.id, 
    1898                                        theory=new_plot, 
    1899                                        state=state) 
     1906                                  theory=new_plot, 
     1907                                  state=state) 
    19001908        current_pg = self.fit_panel.get_page_by_id(page_id) 
    19011909        title = new_plot.title 
    19021910        if not source == 'fit' and plot_result: 
    1903             wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    1904                                                title=title)) 
     1911            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title)) 
    19051912        if toggle_mode_on: 
    19061913            wx.PostEvent(self.parent, 
    1907                              NewPlotEvent(group_id=str(page_id) + " Model1D", 
    1908                                                action="Hide")) 
     1914                         NewPlotEvent(group_id=str(page_id) + " Model1D", 
     1915                                      action="Hide")) 
    19091916        else: 
    19101917            # Chisqr in fitpage 
    19111918            if update_chisqr: 
    1912                 wx.PostEvent(current_pg, 
    1913                              Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
    1914                                                                     weight=weight, 
    1915                                                                     fid=fid, 
    1916                                                          page_id=page_id, 
    1917                                                          index=index))) 
     1919                output = self._cal_chisqr(data=data, 
     1920                                          weight=weight, 
     1921                                          fid=fid, 
     1922                                          page_id=page_id, 
     1923                                          index=index) 
     1924                wx.PostEvent(current_pg, Chi2UpdateEvent(output=output)) 
    19181925            else: 
    19191926                self._plot_residuals(page_id=page_id, data=data, fid=fid, 
    1920                                       index=index, weight=weight) 
     1927                                     index=index, weight=weight) 
    19211928 
    19221929        if not number_finite: 
    19231930            logger.error("Using the present parameters the model does not return any finite value. ") 
    19241931            msg = "Computing Error: Model did not return any finite value." 
    1925             wx.PostEvent(self.parent, StatusEvent(status = msg, info="error")) 
     1932            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    19261933        else: 
    19271934            msg = "Computation  completed!" 
    … …  
    19391946                      weight=None, 
    19401947                      toggle_mode_on=False, 
    1941                        update_chisqr=True, source='model'): 
     1948                      update_chisqr=True, source='model'): 
    19421949        """ 
    19431950        draw model in 2D 
    … …  
    19541961            return None 
    19551962        try: 
    1956             from model_thread import Calc2D 
    19571963            ## If a thread is already started, stop it 
    19581964            if (self.calc_2D is not None) and self.calc_2D.isrunning(): 
    … …  
    19861992    def _draw_model1D(self, model, page_id, data, 
    19871993                      qmin, qmax, smearer=None, 
    1988                 state=None, 
    1989                 weight=None, 
    1990                 fid=None, 
    1991                 toggle_mode_on=False, update_chisqr=True, source='model', 
    1992                 enable1D=True): 
     1994                      state=None, weight=None, fid=None, 
     1995                      toggle_mode_on=False, update_chisqr=True, source='model', 
     1996                      enable1D=True): 
    19931997        """ 
    19941998        Draw model 1D from loaded data1D 
    … …  
    20012005            return 
    20022006        try: 
    2003             from model_thread import Calc1D 
    20042007            ## If a thread is already started, stop it 
    20052008            if (self.calc_1D is not None) and self.calc_1D.isrunning(): 

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

    r0f9ea1c r69363c7  
    11""" 
    2     Calculation thread for modeling 
     2Calculation thread for modeling 
    33""" 
    44 
    55import time 
     6import math 
     7 
    68import numpy as np 
    7 import math 
     9 
    810from sas.sascalc.data_util.calcthread import CalcThread 
    911from sas.sascalc.fit.MultiplicationModel import MultiplicationModel 
    … …  
    2830                 worktime=0.04, 
    2931                 exception_handler=None, 
    30                  ): 
     32                ): 
    3133        CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime, 
    3234                            exception_handler=exception_handler) 
    … …  
    5759        if self.qmax is None: 
    5860            if self.data is not None: 
    59                 newx = math.pow(max(math.fabs(self.data.xmax), 
    60                                    math.fabs(self.data.xmin)), 2) 
    61                 newy = math.pow(max(math.fabs(self.data.ymax), 
    62                                    math.fabs(self.data.ymin)), 2) 
    63                 self.qmax = math.sqrt(newx + newy) 
     61                newx = max(math.fabs(self.data.xmax), math.fabs(self.data.xmin)) 
     62                newy = max(math.fabs(self.data.ymax), math.fabs(self.data.ymin)) 
     63                self.qmax = math.sqrt(newx**2 + newy**2) 
    6464 
    6565        if self.data is None: 
    … …  
    6868 
    6969        # Define matrix where data will be plotted 
    70         radius = np.sqrt((self.data.qx_data * self.data.qx_data) + \ 
    71                     (self.data.qy_data * self.data.qy_data)) 
     70        radius = np.sqrt(self.data.qx_data**2 + self.data.qy_data**2) 
    7271 
    7372        # For theory, qmax is based on 1d qmax 
    7473        # so that must be mulitified by sqrt(2) to get actual max for 2d 
    7574        index_model = (self.qmin <= radius) & (radius <= self.qmax) 
    76         index_model = index_model & self.data.mask 
    77         index_model = index_model & np.isfinite(self.data.data) 
     75        index_model &= self.data.mask 
     76        index_model &= np.isfinite(self.data.data) 
    7877 
    7978        if self.smearer is not None: 
    … …  
    101100        elapsed = time.time() - self.starttime 
    102101        self.complete(image=output, 
    103                        data=self.data, 
    104                        page_id=self.page_id, 
    105                        model=self.model, 
    106                        state=self.state, 
    107                        toggle_mode_on=self.toggle_mode_on, 
    108                        elapsed=elapsed, 
    109                        index=index_model, 
    110                        fid=self.fid, 
    111                        qmin=self.qmin, 
    112                        qmax=self.qmax, 
    113                        weight=self.weight, 
    114                        #qstep=self.qstep, 
    115                        update_chisqr=self.update_chisqr, 
    116                        source=self.source) 
     102                      data=self.data, 
     103                      page_id=self.page_id, 
     104                      model=self.model, 
     105                      state=self.state, 
     106                      toggle_mode_on=self.toggle_mode_on, 
     107                      elapsed=elapsed, 
     108                      index=index_model, 
     109                      fid=self.fid, 
     110                      qmin=self.qmin, 
     111                      qmax=self.qmax, 
     112                      weight=self.weight, 
     113                      #qstep=self.qstep, 
     114                      update_chisqr=self.update_chisqr, 
     115                      source=self.source) 
    117116 
    118117 
    … …  
    138137                 worktime=0.01, 
    139138                 exception_handler=None, 
    140                  ): 
     139                ): 
    141140        """ 
    142141        """ 
    … …  
    193192                                                        * unsmeared_output[first_bin:last_bin+1]\ 
    194193                                                        / output[first_bin:last_bin+1] 
    195                 unsmeared_output=unsmeared_output[index] 
    196                 unsmeared_data=unsmeared_data[index] 
    197                 unsmeared_error=unsmeared_error 
     194                unsmeared_output = unsmeared_output[index] 
     195                unsmeared_data = unsmeared_data[index] 
     196                unsmeared_error = unsmeared_error 
    198197        else: 
    199198            output[index] = self.model.evalDistribution(self.data.x[index]) 
    … …  
    243242    class CalcCommandline: 
    244243        def __init__(self, n=20000): 
    245             #print thread.get_ident() 
    246             from sas.models.CylinderModel import CylinderModel 
    247  
    248             model = CylinderModel() 
    249  
    250  
    251             print model.runXY([0.01, 0.02]) 
     244            #print(thread.get_ident()) 
     245 
     246            from sasmodels.sasview_model import _make_standard_model 
     247            cylinder = _make_standard_model('cylinder') 
     248            model = cylinder() 
     249 
     250            print(model.runXY([0.01, 0.02])) 
    252251 
    253252            qmax = 0.01 
    … …  
    258257            y = numpy.arange(-qmax, qmax+qstep*0.01, qstep) 
    259258 
    260  
    261259            calc_thread_2D = Calc2D(x, y, None, model.clone(),None, 
    262260                                    -qmax, qmax,qstep, 
    263                                             completefn=self.complete, 
    264                                             updatefn=self.update , 
    265                                             yieldtime=0.0) 
     261                                    completefn=self.complete, 
     262                                    updatefn=self.update , 
     263                                    yieldtime=0.0) 
    266264 
    267265            calc_thread_2D.queue() 
    … …  
    272270 
    273271        def update(self,output): 
    274             print "update" 
     272            print("update") 
    275273 
    276274        def complete(self, image, data, model, elapsed, qmin, qmax,index, qstep ): 
    277             print "complete" 
     275            print("complete") 
    278276            self.done = True 
    279277 

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

    r7432acb r78312f7  
    3838        # number of images of plot 
    3939        self.nimages = len(self.report_list[2]) 
    40  
    41         if self.report_list[2] is not None: 
    42             # put image path in the report string 
    43             if len(self.report_list[2]) == 1: 
    44                 self.report_html = self.report_list[0] % \ 
    45                                     "memory:img_fit0.png" 
    46             elif len(self.report_list[2]) == 2: 
    47                 self.report_html = self.report_list[0] % \ 
    48                                     ("memory:img_fit0.png", 
    49                                      "memory:img_fit1.png") 
    50             # allows up to three images 
    51             else: 
    52                 self.report_html = self.report_list[0] % \ 
    53                                     ("memory:img_fit0.png", 
    54                                      "memory:img_fit1.png", 
    55                                      "memory:img_fit2.png") 
    56         else: 
    57             self.report_html = self.report_list[0] 
     40        self.report_html = self.report_list[0] 
    5841        # layout 
    5942        self._setup_layout() 
    … …  
    10588            elif self.nimages == 3: 
    10689                html = report_frame % (str(pic_fname[0]), str(pic_fname[1]), 
    107                                           str(pic_fname[2])) 
     90                                       str(pic_fname[2])) 
    10891 
    10992            # make/open file in case of absence 
    … …  
    118101                    #Windows 
    119102                    os.startfile(str(fName)) 
    120                 except: 
     103                except Exception: 
    121104                    try: 
    122105                        #Mac 
    123106                        os.system("open %s" % fName) 
    124                     except: 
     107                    except Exception: 
    125108                        #DO not open 
    126109                        pass 

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

    ra9f9ca4 r69363c7  
    22    Simultaneous or Batch fit page 
    33""" 
    4 # Note that this is used for both Simultaneous/Constrained fit AND for  
     4# Note that this is used for both Simultaneous/Constrained fit AND for 
    55# combined batch fit.  This is done through setting of the batch_on parameter. 
    6 # There are the a half dozen or so places where an if statement is used as in  
     6# There are the a half dozen or so places where an if statement is used as in 
    77# if not batch_on: 
    88#     xxxx 
    … …  
    1111# This is just wrong but dont have time to fix this go. Proper approach would be 
    1212# to strip all parts of the code that depend on batch_on and create the top 
    13 # level class from which a contrained/simultaneous fit page and a combined  
     13# level class from which a contrained/simultaneous fit page and a combined 
    1414# batch page inherit. 
    1515# 
    … …  
    2323from wx.lib.scrolledpanel import ScrolledPanel 
    2424 
     25from sas.sascalc.fit.pagestate import SimFitPageState 
    2526from sas.sasgui.guiframe.events import StatusEvent, PanelOnFocusEvent 
    2627from sas.sasgui.guiframe.panel_base import PanelBase 
    … …  
    6061 
    6162    return fittable_param 
    62  
    6363 
    6464class SimultaneousFitPage(ScrolledPanel, PanelBase): 
    … …  
    157157        return self.state 
    158158 
     159    def load_from_save_state(self, sim_state): 
     160        """ 
     161        Load in a simultaneous/constrained fit from a save state 
     162        :param fit: Fitpanel object 
     163        :return: None 
     164        """ 
     165        model_map = {} 
     166        # Process each model and associate old M# with new M# 
     167        i = 0 
     168        for model in self.model_list: 
     169            model_id = self._format_id(model[1].keys()[0]) 
     170            for saved_model in sim_state.model_list: 
     171                save_id = saved_model.pop('name') 
     172                saved_model['name'] = save_id 
     173                save_id = self._format_id(save_id) 
     174                if save_id == model_id: 
     175                    model_map[saved_model.pop('fit_page_source')] = \ 
     176                        model[3].name 
     177                    check = bool(saved_model.pop('checked')) 
     178                    self.model_list[i][0].SetValue(check) 
     179                    break 
     180            i += 1 
     181 
     182        self.check_model_name(None) 
     183 
     184        if len(sim_state.constraints_list) > 0: 
     185            self.hide_constraint.SetValue(False) 
     186            self.show_constraint.SetValue(True) 
     187            self._display_constraint(None) 
     188 
     189        for index, item in enumerate(sim_state.constraints_list): 
     190            model_cbox = item.pop('model_cbox') 
     191            if model_cbox != "": 
     192                constraint_value = item.pop('constraint') 
     193                param = item.pop('param_cbox') 
     194                equality = item.pop('egal_txt') 
     195                for key, value in model_map.iteritems(): 
     196                    model_cbox.replace(key, value) 
     197                    constraint_value.replace(key, value) 
     198 
     199                self.constraints_list[index][0].SetValue(model_cbox) 
     200                self._on_select_model(None) 
     201                self.constraints_list[index][1].SetValue(param) 
     202                self.constraints_list[index][2].SetLabel(equality) 
     203                self.constraints_list[index][3].SetValue(constraint_value) 
     204                self._on_add_constraint(None) 
     205                self._manager.sim_page = self 
     206 
     207    def _format_id(self, original_id): 
     208        original_id = original_id.rstrip('1234567890.') 
     209        new_id_list = original_id.split() 
     210        new_id = ' '.join(new_id_list) 
     211        return new_id 
     212 
     213 
     214 
    159215    def draw_page(self): 
    160216        """ 
    161217        Construct the Simultaneous/Constrained fit page. fills the first 
    162         region (sizer1) with the list of available fit page pairs of data  
     218        region (sizer1) with the list of available fit page pairs of data 
    163219        and models.  Then fills sizer2 with the checkbox for adding 
    164220        constraints, and finally fills sizer3 with the fit button and 
    … …  
    10431099        cbox.Append(name, value) 
    10441100    cbox.SetStringSelection(selected) 
    1045  
    1046  
    1047 class SimFitPageState: 
    1048     """ 
    1049     State of the simultaneous fit page for saving purposes 
    1050     """ 
    1051  
    1052     def __init__(self): 
    1053         # Sim Fit Page Number 
    1054         self.fit_page_no = None 
    1055         # Select all data 
    1056         self.select_all = False 
    1057         # Data sets sent to fit page 
    1058         self.model_list = [] 
    1059         # Data sets to be fit 
    1060         self.model_to_fit = [] 
    1061         # Number of constraints 
    1062         self.no_constraint = 0 
    1063         # Dictionary of constraints 
    1064         self.constraint_dict = {} 
    1065         # List of constraints 
    1066         self.constraints_list = [] 
    1067  
    1068     def load_from_save_state(self, fit): 
    1069         """ 
    1070         Load in a simultaneous/constrained fit from a save state 
    1071         :param fit: Fitpanel object 
    1072         :return: None 
    1073         """ 
    1074  
    1075         model_map = {} 
    1076         if fit.fit_panel.sim_page is None: 
    1077             fit.fit_panel.add_sim_page() 
    1078         sim_page = fit.fit_panel.sim_page 
    1079  
    1080         # Process each model and associate old M# with new M# 
    1081         i = 0 
    1082         for model in sim_page.model_list: 
    1083             model_id = self._format_id(model[1].keys()[0]) 
    1084             for saved_model in self.model_list: 
    1085                 save_id = saved_model.pop('name') 
    1086                 saved_model['name'] = save_id 
    1087                 save_id = self._format_id(save_id) 
    1088                 if save_id == model_id: 
    1089                     model_map[saved_model.pop('fit_page_source')] = \ 
    1090                         model[3].name 
    1091                     check = bool(saved_model.pop('checked')) 
    1092                     sim_page.model_list[i][0].SetValue(check) 
    1093                     break 
    1094             i += 1 
    1095         sim_page.check_model_name(None) 
    1096  
    1097         if len(self.constraints_list) > 0: 
    1098             sim_page.hide_constraint.SetValue(False) 
    1099             sim_page.show_constraint.SetValue(True) 
    1100             sim_page._display_constraint(None) 
    1101  
    1102         for index, item in enumerate(self.constraints_list): 
    1103             model_cbox = item.pop('model_cbox') 
    1104             if model_cbox != "": 
    1105                 constraint_value = item.pop('constraint') 
    1106                 param = item.pop('param_cbox') 
    1107                 equality = item.pop('egal_txt') 
    1108                 for key, value in model_map.iteritems(): 
    1109                     model_cbox.replace(key, value) 
    1110                     constraint_value.replace(key, value) 
    1111  
    1112                 sim_page.constraints_list[index][0].SetValue(model_cbox) 
    1113                 sim_page._on_select_model(None) 
    1114                 sim_page.constraints_list[index][1].SetValue(param) 
    1115                 sim_page.constraints_list[index][2].SetLabel(equality) 
    1116                 sim_page.constraints_list[index][3].SetValue(constraint_value) 
    1117                 sim_page._on_add_constraint(None) 
    1118                 sim_page._manager.sim_page = sim_page 
    1119  
    1120     def _format_id(self, original_id): 
    1121         original_id = original_id.rstrip('1234567890.') 
    1122         new_id_list = original_id.split() 
    1123         new_id = ' '.join(new_id_list) 
    1124         return new_id 
Note: See TracChangeset for help on using the changeset viewer.