Changeset ba8d326 in sasview


Ignore:
Timestamp:
Jun 23, 2017 4:16:29 PM (6 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:
98e3f24
Parents:
81b35396
git-author:
Paul Kienzle <pkienzle@…> (06/21/17 12:38:48)
git-committer:
Paul Kienzle <pkienzle@…> (06/23/17 16:16:29)
Message:

code cleanup

Location:
src/sas
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sascalc/fit/pagestate.py

    r81b35396 rba8d326  
    11""" 
    2     Class that holds a fit page state 
     2Class that holds a fit page state 
    33""" 
    44# TODO: Refactor code so we don't need to use getattr/setattr 
     
    4040# Information to read/write state as xml 
    4141FITTING_NODE_NAME = 'fitting_plug_in' 
    42 CANSAS_NS = "cansas1d/1.0" 
     42CANSAS_NS = {"ns": "cansas1d/1.0"} 
    4343 
    4444CUSTOM_MODEL = 'Plugin Models' 
     
    8383                            ["weights", "weights"]] 
    8484 
    85 DISPERSION_LIST = [["disp_obj_dict", "_disp_obj_dict", "string"]] 
     85DISPERSION_LIST = [["disp_obj_dict", "disp_obj_dict", "string"]] 
    8686 
    8787LIST_OF_STATE_PARAMETERS = [["parameters", "parameters"], 
     
    154154        self.timestamp = time.time() 
    155155        # Data member to store the dispersion object created 
    156         self._disp_obj_dict = {} 
     156        self.disp_obj_dict = {} 
    157157        # ------------------------ 
    158158        # Data used for fitting 
     
    271271        # store value of chisqr 
    272272        self.tcChi = None 
    273         self.version = (1,0,0) 
     273        self.version = (1, 0, 0) 
    274274 
    275275    def clone(self): 
     
    315315        obj.tcChi = self.tcChi 
    316316 
    317         if len(self._disp_obj_dict) > 0: 
    318             for k, v in self._disp_obj_dict.iteritems(): 
    319                 obj._disp_obj_dict[k] = v 
     317        if len(self.disp_obj_dict) > 0: 
     318            for k, v in self.disp_obj_dict.iteritems(): 
     319                obj.disp_obj_dict[k] = v 
    320320        if len(self.disp_cb_dict) > 0: 
    321321            for k, v in self.disp_cb_dict.iteritems(): 
     
    847847            inputs.appendChild(element) 
    848848 
    849         # Create doc for the dictionary of self._disp_obj_dic 
     849        # Create doc for the dictionary of self.disp_obj_dic 
    850850        for tagname, varname, tagtype in DISPERSION_LIST: 
    851851            element = newdoc.createElement(tagname) 
     
    928928        """ 
    929929        for item in node: 
    930             try: 
    931                 name = item.get('name') 
    932             except: 
    933                 name = None 
    934             try: 
    935                 value = item.get('value') 
    936             except: 
    937                 value = None 
    938             try: 
    939                 selected_to_fit = (item.get('selected_to_fit') == "True") 
    940             except: 
    941                 selected_to_fit = None 
    942             try: 
    943                 error_displayed = (item.get('error_displayed') == "True") 
    944             except: 
    945                 error_displayed = None 
    946             try: 
    947                 error_value = item.get('error_value') 
    948             except: 
    949                 error_value = None 
    950             try: 
    951                 minimum_displayed = (item.get('minimum_displayed') == "True") 
    952             except: 
    953                 minimum_displayed = None 
    954             try: 
    955                 minimum_value = item.get('minimum_value') 
    956             except: 
    957                 minimum_value = None 
    958             try: 
    959                 maximum_displayed = (item.get('maximum_displayed') == "True") 
    960             except: 
    961                 maximum_displayed = None 
    962             try: 
    963                 maximum_value = item.get('maximum_value') 
    964             except: 
    965                 maximum_value = None 
    966             try: 
    967                 unit = item.get('unit') 
    968             except: 
    969                 unit = None 
     930            name = item.get('name') 
     931            value = item.get('value') 
     932            selected_to_fit = (item.get('selected_to_fit') == "True") 
     933            error_displayed = (item.get('error_displayed') == "True") 
     934            error_value = item.get('error_value') 
     935            minimum_displayed = (item.get('minimum_displayed') == "True") 
     936            minimum_value = item.get('minimum_value') 
     937            maximum_displayed = (item.get('maximum_displayed') == "True") 
     938            maximum_value = item.get('maximum_value') 
     939            unit = item.get('unit') 
    970940            list.append([selected_to_fit, name, value, "+/-", 
    971941                         [error_displayed, error_value], 
     
    10331003                                          list=getattr(self, item[1])) 
    10341004 
    1035                 # Recover _disp_obj_dict from xml file 
    1036                 self._disp_obj_dict = {} 
     1005                # Recover disp_obj_dict from xml file 
     1006                self.disp_obj_dict = {} 
    10371007                for tagname, varname, tagtype in DISPERSION_LIST: 
    10381008                    node = get_content("ns:%s" % tagname, entry) 
     
    10481018                            except Exception: 
    10491019                                base = "unable to load distribution %r for %s" 
    1050                                 logger.error(base % (value, parameter)) 
     1020                                logger.error(base, value, parameter) 
    10511021                                continue 
    1052                         _disp_obj_dict = getattr(self, varname) 
    1053                         _disp_obj_dict[parameter] = value 
     1022                        disp_obj_dict = getattr(self, varname) 
     1023                        disp_obj_dict[parameter] = value 
    10541024 
    10551025                # get self.values and self.weights dic. if exists 
     
    10741044                    setattr(self, varname, dic) 
    10751045 
    1076 class SimFitPageState: 
     1046class SimFitPageState(object): 
    10771047    """ 
    10781048    State of the simultaneous fit page for saving purposes 
     
    10951065        self.constraints_list = [] 
    10961066 
     1067    def __repr__(self): 
     1068        # TODO: should use __str__, not __repr__ (similarly for PageState) 
     1069        # TODO: could use a nicer representation 
     1070        repr = """\ 
     1071fit page number : %(fit_page_no)s 
     1072select all : %(select_all)s 
     1073model_list : %(model_list)s 
     1074model to fit : %(model_to_fit)s 
     1075number of construsts : %(no_constraint)s 
     1076constraint dict : %(constraint_dict)s 
     1077constraints list : %(constraints_list)s 
     1078"""%self.__dict__ 
     1079        return repr 
     1080 
    10971081class Reader(CansasReader): 
    10981082    """ 
     
    11521136        try: 
    11531137            nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, 
    1154                                 namespaces={'ns': CANSAS_NS}) 
     1138                                namespaces=CANSAS_NS) 
    11551139            if nodes: 
    11561140                # Create an empty state 
     
    11581142                state.from_xml(node=nodes[0]) 
    11591143 
    1160         except: 
     1144        except Exception: 
    11611145            logger.info("XML document does not contain fitting information.\n" 
    1162                          + traceback.format_exc()) 
     1146                        + traceback.format_exc()) 
    11631147 
    11641148        return state 
     
    11711155        """ 
    11721156        nodes = entry.xpath('ns:%s' % FITTING_NODE_NAME, 
    1173                             namespaces={'ns': CANSAS_NS}) 
     1157                            namespaces=CANSAS_NS) 
    11741158        if nodes: 
    11751159            simfitstate = nodes[0].xpath('ns:simultaneous_fit', 
    1176                                          namespaces={'ns': CANSAS_NS}) 
     1160                                         namespaces=CANSAS_NS) 
    11771161            if simfitstate: 
    11781162                sim_fit_state = SimFitPageState() 
    11791163                simfitstate_0 = simfitstate[0] 
    11801164                all = simfitstate_0.xpath('ns:select_all', 
    1181                                           namespaces={'ns': CANSAS_NS}) 
     1165                                          namespaces=CANSAS_NS) 
    11821166                atts = all[0].attrib 
    11831167                checked = atts.get('checked') 
    11841168                sim_fit_state.select_all = bool(checked) 
    11851169                model_list = simfitstate_0.xpath('ns:model_list', 
    1186                                                  namespaces={'ns': CANSAS_NS}) 
     1170                                                 namespaces=CANSAS_NS) 
    11871171                model_list_items = model_list[0].xpath('ns:model_list_item', 
    1188                                                        namespaces={'ns': 
    1189                                                                     CANSAS_NS}) 
     1172                                                       namespaces=CANSAS_NS) 
    11901173                for model in model_list_items: 
    11911174                    attrs = model.attrib 
     
    11931176 
    11941177                constraints = simfitstate_0.xpath('ns:constraints', 
    1195                                                 namespaces={'ns': CANSAS_NS}) 
     1178                                                  namespaces=CANSAS_NS) 
    11961179                constraint_list = constraints[0].xpath('ns:constraint', 
    1197                                                namespaces={'ns': CANSAS_NS}) 
     1180                                                       namespaces=CANSAS_NS) 
    11981181                for constraint in constraint_list: 
    11991182                    attrs = constraint.attrib 
     
    12131196 
    12141197        """ 
    1215         node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS}) 
     1198        node = dom.xpath('ns:data_class', namespaces=CANSAS_NS) 
    12161199        return_value, _ = self._parse_entry(dom) 
    12171200        return return_value, _ 
     
    12421225                    root = tree.getroot() 
    12431226                    entry_list = root.xpath('ns:SASentry', 
    1244                                             namespaces={'ns': CANSAS_NS}) 
     1227                                            namespaces=CANSAS_NS) 
    12451228                    for entry in entry_list: 
    12461229                        try: 
     
    12661249                return None 
    12671250            else: 
    1268                 for ind in range(len(output)): 
     1251                for data in output: 
    12691252                    # Call back to post the new state 
    1270                     state = output[ind].meta_data['fitstate'] 
     1253                    state = data.meta_data['fitstate'] 
    12711254                    t = time.localtime(state.timestamp) 
    12721255                    time_str = time.strftime("%b %d %H:%M", t) 
     
    12791262 
    12801263                    if state is not None and state.is_data is not None: 
    1281                         output[ind].is_data = state.is_data 
    1282  
    1283                     output[ind].filename = state.file 
    1284                     state.data = output[ind] 
    1285                     state.data.name = output[ind].filename  # state.data_name 
     1264                        data.is_data = state.is_data 
     1265 
     1266                    data.filename = state.file 
     1267                    state.data = data 
     1268                    state.data.name = data.filename  # state.data_name 
    12861269                    state.data.id = state.data_id 
    12871270                    if state.is_data is not None: 
    12881271                        state.data.is_data = state.is_data 
    1289                     if output[ind].run_name is not None\ 
    1290                          and len(output[ind].run_name) != 0: 
    1291                         if isinstance(output[ind].run_name, dict): 
    1292                             name = output[ind].run_name.keys()[0] 
     1272                    if data.run_name is not None and len(data.run_name) != 0: 
     1273                        if isinstance(data.run_name, dict): 
     1274                            # Note: key order in dict is not guaranteed, so sort 
     1275                            name = data.run_name.keys()[0] 
    12931276                        else: 
    1294                             name = output[ind].run_name 
     1277                            name = data.run_name 
    12951278                    else: 
    12961279                        name = original_fname 
     
    12981281                    state.version = fitstate.version 
    12991282                    # store state in fitting 
    1300                     self.call_back(state=state, 
    1301                                    datainfo=output[ind], format=ext) 
     1283                    self.call_back(state=state, datainfo=data, format=ext) 
    13021284                    self.state = state 
    13031285                simfitstate = self._parse_simfit_state(entry) 
  • src/sas/sasgui/perspectives/fitting/basepage.py

    r81b35396 rba8d326  
    285285        """ 
    286286        x = np.linspace(start=self.qmin_x, stop=self.qmax_x, 
    287                            num=self.npts_x, endpoint=True) 
     287                        num=self.npts_x, endpoint=True) 
    288288        self.data = Data1D(x=x) 
    289289        self.data.xaxis('\\rm{Q}', "A^{-1}") 
     
    311311 
    312312        x = np.logspace(start=qmin, stop=qmax, 
    313                            num=self.npts_x, endpoint=True, base=10.0) 
     313                        num=self.npts_x, endpoint=True, base=10.0) 
    314314        self.data = Data1D(x=x) 
    315315        self.data.xaxis('\\rm{Q}', "A^{-1}") 
     
    904904        if len(self._disp_obj_dict) > 0: 
    905905            for k, v in self._disp_obj_dict.iteritems(): 
    906                 self.state._disp_obj_dict[k] = v.type 
     906                self.state.disp_obj_dict[k] = v.type 
    907907 
    908908            self.state.values = copy.deepcopy(self.values) 
     
    922922                                    self.state.str_parameters) 
    923923        self._copy_parameters_state(self.orientation_params, 
    924                                      self.state.orientation_params) 
     924                                    self.state.orientation_params) 
    925925        self._copy_parameters_state(self.orientation_params_disp, 
    926926                                    self.state.orientation_params_disp) 
     
    976976                        try: 
    977977                            self.state.disp_cb_dict[k] = v.GetValue() 
    978                         except: 
     978                        except Exception: 
    979979                            self.state.disp_cb_dict[k] = None 
    980980            if len(self._disp_obj_dict) > 0: 
    981981                for k, v in self._disp_obj_dict.iteritems(): 
    982                     self.state._disp_obj_dict[k] = v.type 
     982                    self.state.disp_obj_dict[k] = v.type 
    983983 
    984984            self.state.values = copy.deepcopy(self.values) 
     
    10221022            # to support older version 
    10231023            category_pos = int(state.categorycombobox) 
    1024         except: 
     1024        except Exception: 
    10251025            category_pos = 0 
    10261026            for ind_cat in range(self.categorybox.GetCount()): 
     
    10341034            # to support older version 
    10351035            formfactor_pos = int(state.formfactorcombobox) 
    1036         except: 
     1036        except Exception: 
    10371037            formfactor_pos = 0 
    10381038            for ind_form in range(self.formfactorbox.GetCount()): 
     
    10471047            # to support older version 
    10481048            structfactor_pos = int(state.structurecombobox) 
    1049         except: 
     1049        except Exception: 
    10501050            structfactor_pos = 0 
    10511051            for ind_struct in range(self.structurebox.GetCount()): 
     
    12841284            self.dI_sqrdata.SetValue(state.dI_sqrdata) 
    12851285            self.dI_idata.SetValue(state.dI_idata) 
    1286         except: 
     1286        except Exception: 
    12871287            # to support older state file formats 
    12881288            self.dI_noweight.SetValue(False) 
     
    13401340        self.weights = copy.deepcopy(state.weights) 
    13411341 
    1342         for key, disp_type in state._disp_obj_dict.iteritems(): 
     1342        for key, disp_type in state.disp_obj_dict.iteritems(): 
    13431343            # disp_model = disp 
    13441344            disp_model = POLYDISPERSITY_MODELS[disp_type]() 
     
    15741574                        try: 
    15751575                            self.npts_x = float(self.Npts_total.GetValue()) 
    1576                         except: 
     1576                        except Exception: 
    15771577                            flag = False 
    15781578                            return flag 
     
    16151615            return 
    16161616 
    1617         for j in range(len(listtorestore)): 
     1617        for item_page in listtorestore: 
    16181618            for param in statelist: 
    1619                 if param[1] == listtorestore[j][1]: 
    1620                     item_page = listtorestore[j] 
     1619                if param[1] == item_page[1]: 
    16211620                    item_page_info = param 
    16221621                    if (item_page_info[1] == "theta" or item_page_info[1] == 
     
    16641663        listtorestore = copy.deepcopy(statelist) 
    16651664 
    1666         for j in range(len(listtorestore)): 
    1667             item_page = listtorestore[j] 
    1668             item_page_info = statelist[j] 
     1665        for item_page, item_page_info in zip(listtorestore, statelist): 
    16691666            # change the state of the check box for simple parameters 
    1670  
    16711667            if item_page[0] is not None: 
    16721668                item_page[0].SetValue(format_number(item_page_info[0], True)) 
     
    19211917                    wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    19221918                    return 
    1923             except: 
     1919            except Exception: 
    19241920                tcrtl.SetBackgroundColour("pink") 
    19251921                msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1] 
     
    19781974                    wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    19791975                    return 
    1980             except: 
     1976            except Exception: 
    19811977                tcrtl.SetBackgroundColour("pink") 
    19821978                msg = "Model Error: wrong value entered: %s" % sys.exc_info()[1] 
     
    21562152            # q value from qx and qy 
    21572153            radius = np.sqrt(data.qx_data * data.qx_data + 
    2158                                 data.qy_data * data.qy_data) 
     2154                             data.qy_data * data.qy_data) 
    21592155            # get unmasked index 
    21602156            index_data = (float(self.qmin.GetValue()) <= radius) & \ 
     
    23852381        put gaussian dispersity into current model 
    23862382        """ 
    2387         if len(self.param_toFit) > 0: 
     2383        if self.param_toFit: 
    23882384            for item in self.fittable_param: 
    23892385                if item in self.param_toFit: 
     
    24022398        # from sas.models.dispersion_models import GaussianDispersion 
    24032399        from sasmodels.weights import GaussianDispersion 
    2404         if len(self.disp_cb_dict) == 0: 
    2405             self.save_current_state() 
     2400        if not self.disp_cb_dict: 
    24062401            self.sizer4_4.Clear(True) 
    2407             self.Layout() 
    2408             return 
    2409         if (len(self.disp_cb_dict) > 0): 
     2402        else: 
    24102403            for p in self.disp_cb_dict: 
    24112404                # The parameter was un-selected. 
     
    24802473                self._disp_obj_dict[name1] = disp_model 
    24812474                self.model.set_dispersion(param_name, disp_model) 
    2482                 self.state._disp_obj_dict[name1] = disp_model.type 
     2475                self.state.disp_obj_dict[name1] = disp_model.type 
    24832476 
    24842477                value1 = str(format_number(self.model.getParam(name1), True)) 
     
    25952588        self._disp_obj_dict[name] = disp 
    25962589        self.model.set_dispersion(name.split('.')[0], disp) 
    2597         self.state._disp_obj_dict[name] = disp.type 
     2590        self.state.disp_obj_dict[name] = disp.type 
    25982591        self.values[name] = values 
    25992592        self.weights[name] = weights 
     
    29532946            # go through the parameters 
    29542947            strings = self._get_copy_helper(self.parameters, 
    2955                                            self.orientation_params) 
     2948                                            self.orientation_params) 
    29562949            content += strings 
    29572950 
    29582951            # go through the fittables 
    29592952            strings = self._get_copy_helper(self.fittable_param, 
    2960                                            self.orientation_params_disp) 
     2953                                            self.orientation_params_disp) 
    29612954            content += strings 
    29622955 
    29632956            # go through the fixed params 
    29642957            strings = self._get_copy_helper(self.fixed_param, 
    2965                                            self.orientation_params_disp) 
     2958                                            self.orientation_params_disp) 
    29662959            content += strings 
    29672960 
    29682961            # go through the str params 
    29692962            strings = self._get_copy_helper(self.str_parameters, 
    2970                                            self.orientation_params) 
     2963                                            self.orientation_params) 
    29712964            content += strings 
    29722965            return content 
     
    30273020        Get the string copies of the param names and values in the tap 
    30283021        """ 
    3029         content = '\\begin{table}' 
    3030         content += '\\begin{tabular}[h]' 
     3022        content = r'\begin{table}' 
     3023        content += r'\begin{tabular}[h]' 
    30313024 
    30323025        crlf = chr(13) + chr(10) 
     
    30393032            for param in self.parameters: 
    30403033                content += 'l|l|' 
    3041             content += '}\hline' 
     3034            content += r'}\hline' 
    30423035            content += crlf 
    30433036 
    30443037            for index, param in enumerate(self.parameters): 
    3045                 content += param[1].replace('_', '\_')  # parameter name 
     3038                content += param[1].replace('_', r'\_')  # parameter name 
    30463039                content += ' & ' 
    3047                 content += param[1].replace('_', '\_') + "\_err" 
     3040                content += param[1].replace('_', r'\_') + r'\_err' 
    30483041                if index < len(self.parameters) - 1: 
    30493042                    content += ' & ' 
    3050             content += '\\\\ \\hline' 
     3043            content += r'\\ \hline' 
    30513044            content += crlf 
    30523045 
     
    30583051                if index < len(self.parameters) - 1: 
    30593052                    content += ' & ' 
    3060             content += '\\\\ \\hline' 
     3053            content += r'\\ \hline' 
    30613054            content += crlf 
    30623055 
    3063             content += '\\end{tabular}' 
    3064             content += '\\end{table}' 
     3056            content += r'\end{tabular}' 
     3057            content += r'\end{table}' 
    30653058            return content 
    30663059        else: 
     
    33203313                                if name.endswith('.npts'): 
    33213314                                    pd = int(pd) 
    3322                             except: 
     3315                            except Exception: 
    33233316                                # continue 
    33243317                                if not pd and pd != '': 
     
    34063399                self._disp_obj_dict[name] = disp_model 
    34073400                self.model.set_dispersion(param_name, disp_model) 
    3408                 self.state._disp_obj_dict[name] = disp_model.type 
     3401                self.state.disp_obj_dict[name] = disp_model.type 
    34093402                # TODO: It's not an array, why update values and weights? 
    34103403                self.model._persistency_dict[param_name] = \ 
     
    35123505 
    35133506        else: 
    3514             for (model, enabled) in sorted(self.master_category_dict[category], 
    3515                                            key=lambda name: name[0]): 
    3516                 if(enabled): 
     3507            for model, enabled in sorted(self.master_category_dict[category], 
     3508                                         key=lambda name: name[0]): 
     3509                if enabled: 
    35173510                    self.model_box.Append(model) 
    35183511 
     
    37553748        self.Bind(wx.EVT_SET_FOCUS, self._on_set_focus) 
    37563749        self.Bind(wx.EVT_KILL_FOCUS, self._silent_kill_focus 
    3757         if kill_focus_callback is None else kill_focus_callback) 
     3750                  if kill_focus_callback is None else kill_focus_callback) 
    37583751        self.Bind(wx.EVT_TEXT_ENTER, parent._onparamEnter 
    3759         if text_enter_callback is None else text_enter_callback) 
     3752                  if text_enter_callback is None else text_enter_callback) 
    37603753        if not ON_MAC: 
    37613754            self.Bind(wx.EVT_LEFT_UP, self._highlight_text 
    3762             if mouse_up_callback is None else mouse_up_callback) 
     3755                      if mouse_up_callback is None else mouse_up_callback) 
    37633756 
    37643757    def _on_set_focus(self, event): 
  • 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/model_thread.py

    r7432acb rba8d326  
    11""" 
    2     Calculation thread for modeling 
     2Calculation thread for modeling 
    33""" 
    44 
     
    2828                 worktime=0.04, 
    2929                 exception_handler=None, 
    30                  ): 
     30                ): 
    3131        CalcThread.__init__(self, completefn, updatefn, yieldtime, worktime, 
    3232                            exception_handler=exception_handler) 
     
    5757        if self.qmax is None: 
    5858            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) 
     59                newx = max(math.fabs(self.data.xmax), math.fabs(self.data.xmin)) 
     60                newy = max(math.fabs(self.data.ymax), math.fabs(self.data.ymin)) 
     61                self.qmax = math.sqrt(newx**2 + newy**2) 
    6462 
    6563        if self.data is None: 
     
    6866 
    6967        # 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)) 
    72  
    73         # For theory, qmax is based on 1d qmax  
     68        radius = np.sqrt(self.data.qx_data**2 + self.data.qy_data**2) 
     69 
     70        # For theory, qmax is based on 1d qmax 
    7471        # so that must be mulitified by sqrt(2) to get actual max for 2d 
    7572        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) 
     73        index_model &= self.data.mask 
     74        index_model &= np.isfinite(self.data.data) 
    7875 
    7976        if self.smearer is not None: 
     
    10097        elapsed = time.time() - self.starttime 
    10198        self.complete(image=output, 
    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) 
     99                      data=self.data, 
     100                      page_id=self.page_id, 
     101                      model=self.model, 
     102                      state=self.state, 
     103                      toggle_mode_on=self.toggle_mode_on, 
     104                      elapsed=elapsed, 
     105                      index=index_model, 
     106                      fid=self.fid, 
     107                      qmin=self.qmin, 
     108                      qmax=self.qmax, 
     109                      weight=self.weight, 
     110                      #qstep=self.qstep, 
     111                      update_chisqr=self.update_chisqr, 
     112                      source=self.source) 
    116113 
    117114 
     
    137134                 worktime=0.01, 
    138135                 exception_handler=None, 
    139                  ): 
     136                ): 
    140137        """ 
    141138        """ 
     
    192189                                                        * unsmeared_output[first_bin:last_bin+1]\ 
    193190                                                        / output[first_bin:last_bin+1] 
    194                 unsmeared_output=unsmeared_output[index] 
    195                 unsmeared_data=unsmeared_data[index] 
    196                 unsmeared_error=unsmeared_error 
     191                unsmeared_output = unsmeared_output[index] 
     192                unsmeared_data = unsmeared_data[index] 
     193                unsmeared_error = unsmeared_error 
    197194        else: 
    198195            output[index] = self.model.evalDistribution(self.data.x[index]) 
  • src/sas/sasgui/perspectives/fitting/models.py

    r8cec26b rba8d326  
    6868    try: 
    6969        new_instance = model() 
    70     except: 
     70    except Exception: 
    7171        msg = "Plugin %s error in __init__ \n\t: %s %s\n" % (str(name), 
    7272                                                             str(sys.exc_type), 
     
    7878        try: 
    7979            value = new_instance.function() 
    80         except: 
     80        except Exception: 
    8181            msg = "Plugin %s: error writing function \n\t :%s %s\n " % \ 
    8282                    (str(name), str(sys.exc_type), sys.exc_info()[1]) 
     
    102102 
    103103    # Find paths needed 
     104    # TODO: remove unneeded try/except block 
    104105    try: 
    105106        # For source 
     
    108109        else: 
    109110            raise 
    110     except: 
     111    except Exception: 
    111112        # Check for data path next to exe/zip file. 
    112113        #Look for maximum n_dir up of the current dir to find plugins dir 
     
    158159        compileall.compile_dir(dir=dir, ddir=dir, force=0, 
    159160                               quiet=report_problem) 
    160     except: 
     161    except Exception: 
    161162        return sys.exc_info()[1] 
    162163    return None 
     
    177178    plugin_log("looking for models in: %s" % str(directory)) 
    178179    # compile_file(directory)  #always recompile the folder plugin 
    179     logger.info("plugin model dir: %s" % str(directory)) 
     180    logger.info("plugin model dir: %s", str(directory)) 
    180181 
    181182    plugins = {} 
     
    192193                msg += "\nwhile accessing model in %r" % path 
    193194                plugin_log(msg) 
    194                 logger.warning("Failed to load plugin %r. See %s for details" 
    195                                % (path, PLUGIN_LOG)) 
     195                logger.warning("Failed to load plugin %r. See %s for details", 
     196                               path, PLUGIN_LOG) 
    196197 
    197198    return plugins 
     
    230231 
    231232 
    232 class ModelManagerBase: 
     233class ModelManagerBase(object): 
    233234    """ 
    234235    Base class for the model manager 
     
    265266        if self.is_changed(): 
    266267            return  _find_models() 
    267         logger.info("plugin model : %s" % str(temp)) 
     268        logger.info("plugin model : %s", str(temp)) 
    268269        return temp 
    269270 
     
    297298        for name, plug in self.stored_plugins.iteritems(): 
    298299            self.model_dictionary[name] = plug 
    299          
     300 
    300301        self._get_multifunc_models() 
    301302 
Note: See TracChangeset for help on using the changeset viewer.