Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

    rd4ba565 rbb477f5  
    569569            menu.exec_(self.lstParams.viewport().mapToGlobal(position)) 
    570570        except AttributeError as ex: 
    571             logging.error("Error generating context menu: %s" % ex) 
     571            logger.error("Error generating context menu: %s" % ex) 
    572572        return 
    573573 
     
    14561456            self.communicate.statusBarUpdateSignal.emit(msg) 
    14571457            msg += results.mesg 
    1458             logging.error(msg) 
     1458            logger.error(msg) 
    14591459            return 
    14601460 
     
    14991499        if self.calc_fit._interrupting: 
    15001500            msg = "Fitting cancelled by user after: %s s." % GuiUtils.formatNumber(elapsed) 
    1501             logging.warning("\n"+msg+"\n") 
     1501            logger.warning("\n"+msg+"\n") 
    15021502        else: 
    15031503            msg = "Fitting completed successfully in: %s s." % GuiUtils.formatNumber(elapsed) 
     
    18411841        data_to_show = self.data if self.data_is_loaded else self.model_data 
    18421842        if data_to_show is not None: 
    1843             self.communicate.plotRequestedSignal.emit([data_to_show]) 
     1843            self.communicate.plotRequestedSignal.emit([data_to_show], self.tab_id) 
    18441844 
    18451845    def onOptionsUpdate(self): 
     
    20522052                kernel_module = generate.load_kernel_module(name) 
    20532053            except ModuleNotFoundError as ex: 
    2054                 logging.error("Can't find the model "+ str(ex)) 
     2054                logger.error("Can't find the model "+ str(ex)) 
    20552055                return 
    20562056 
     
    21022102            return 
    21032103 
     2104        product_params = None 
     2105 
    21042106        if self.kernel_module is None: 
    21052107            # Structure factor is the only selected model; build it and show all its params 
     
    21072109            s_params = self.kernel_module._model_info.parameters 
    21082110            s_params_orig = s_params 
    2109  
    21102111        else: 
    21112112            s_kernel = self.models[structure_factor]() 
     
    21242125            if "radius_effective_mode" in all_param_names: 
    21252126                # Show all parameters 
     2127                # In this case, radius_effective is NOT pruned by sasmodels.product 
    21262128                s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len]) 
    21272129                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters) 
     2130                product_params = modelinfo.ParameterTable( 
     2131                        self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:]) 
    21282132            else: 
    21292133                # Ensure radius_effective is not displayed 
    21302134                s_params_orig = modelinfo.ParameterTable(s_kernel._model_info.parameters.kernel_parameters[1:]) 
    21312135                if "radius_effective" in all_param_names: 
     2136                    # In this case, radius_effective is NOT pruned by sasmodels.product 
    21322137                    s_params = modelinfo.ParameterTable(all_params[p_pars_len+1:p_pars_len+s_pars_len]) 
     2138                    product_params = modelinfo.ParameterTable( 
     2139                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len:]) 
    21332140                else: 
     2141                    # In this case, radius_effective is pruned by sasmodels.product 
    21342142                    s_params = modelinfo.ParameterTable(all_params[p_pars_len:p_pars_len+s_pars_len-1]) 
     2143                    product_params = modelinfo.ParameterTable( 
     2144                            self.kernel_module._model_info.parameters.kernel_parameters[p_pars_len+s_pars_len-1:]) 
    21352145 
    21362146        # Add heading row 
     
    21402150        # Any renamed parameters are stored as data in the relevant item, for later handling 
    21412151        FittingUtilities.addSimpleParametersToModel( 
    2142                 s_params, 
    2143                 self.is2D, 
    2144                 s_params_orig, 
    2145                 self._model_model, 
    2146                 self.lstParams) 
     2152                parameters=s_params, 
     2153                is2D=self.is2D, 
     2154                parameters_original=s_params_orig, 
     2155                model=self._model_model, 
     2156                view=self.lstParams) 
     2157 
     2158        # Insert product-only params into QModel 
     2159        if product_params: 
     2160            prod_rows = FittingUtilities.addSimpleParametersToModel( 
     2161                    parameters=product_params, 
     2162                    is2D=self.is2D, 
     2163                    parameters_original=None, 
     2164                    model=self._model_model, 
     2165                    view=self.lstParams, 
     2166                    row_num=2) 
     2167 
     2168            # Since this all happens after shells are dealt with and we've inserted rows, fix this counter 
     2169            self._n_shells_row += len(prod_rows) 
    21472170 
    21482171    def haveParamsToFit(self): 
     
    22642287            fitted_data.symbol = "Line" 
    22652288            self.createTheoryIndex(fitted_data) 
     2289            # Switch to the theory tab for user's glee 
     2290            self.communicate.changeDataExplorerTabSignal.emit(1) 
    22662291 
    22672292    def updateModelIndex(self, fitted_data): 
     
    23992424 
    24002425        if self.data_is_loaded: 
     2426            # delete any plots associated with the data that were not updated (e.g. to remove beta(Q), S_eff(Q)) 
    24012427            GuiUtils.deleteRedundantPlots(self.all_data[self.data_index], new_plots) 
     2428            pass 
    24022429        else: 
    24032430            # delete theory items for the model, in order to get rid of any redundant items, e.g. beta(Q), S_eff(Q) 
     
    24052432 
    24062433        # Create plots for intermediate product data 
    2407         pq_data, sq_data = self.logic.new1DProductPlots(return_data, self.tab_id) 
    2408         if pq_data is not None: 
    2409             pq_data.symbol = "Line" 
    2410             self.createNewIndex(pq_data) 
    2411             # self.communicate.plotUpdateSignal.emit([pq_data]) 
    2412             new_plots.append(pq_data) 
    2413         if sq_data is not None: 
    2414             sq_data.symbol = "Line" 
    2415             self.createNewIndex(sq_data) 
    2416             # self.communicate.plotUpdateSignal.emit([sq_data]) 
    2417             new_plots.append(sq_data) 
     2434        plots = self.logic.new1DProductPlots(return_data, self.tab_id) 
     2435        for plot in plots: 
     2436            plot.symbol = "Line" 
     2437            self.createNewIndex(plot) 
     2438            new_plots.append(plot) 
    24182439 
    24192440        for plot in new_plots: 
     
    24942515        """ 
    24952516        # TODO: remimplement thread cancellation 
    2496         logging.error("".join(traceback.format_exception(etype, value, tb))) 
     2517        logger.error("".join(traceback.format_exception(etype, value, tb))) 
    24972518 
    24982519    def setTableProperties(self, table): 
     
    26762697 
    26772698        if not datafile: 
    2678             logging.info("No weight data chosen.") 
     2699            logger.info("No weight data chosen.") 
    26792700            raise IOError 
    26802701 
     
    27922813        self._n_shells_row = shell_row - 1 
    27932814 
    2794         # Set the index to the state-kept value 
    2795         func.setCurrentIndex(self.current_shell_displayed 
    2796                              if self.current_shell_displayed < func.count() else 0) 
     2815        # Get the default number of shells for the model 
     2816        kernel_pars = self.kernel_module._model_info.parameters.kernel_parameters 
     2817        shell_par = None 
     2818        for par in kernel_pars: 
     2819            if par.name == param_name: 
     2820                shell_par = par 
     2821                break 
     2822        if not shell_par: 
     2823            logger.error("Could not find %s in kernel parameters.", param_name) 
     2824        default_shell_count = shell_par.default 
     2825 
     2826        # Add default number of shells to the model 
     2827        func.setCurrentIndex(default_shell_count) 
    27972828 
    27982829    def modifyShellsInList(self, index): 
     
    28162847        self._num_shell_params = len(new_rows) 
    28172848        self.current_shell_displayed = index 
     2849 
     2850        # Change 'n' in the parameter model, thereby updating the underlying model 
     2851        self._model_model.item(self._n_shells_row, 1).setText(str(index)) 
    28182852 
    28192853        # Update relevant models 
     
    31053139            param_value = str(self._model_model.item(row, 1).text()) 
    31063140            param_error = None 
     3141            param_min = None 
     3142            param_max = None 
    31073143            column_offset = 0 
    31083144            if self.has_error_column: 
    31093145                param_error = str(self._model_model.item(row, 2).text()) 
    31103146                column_offset = 1 
    3111             param_min = str(self._model_model.item(row, 2+column_offset).text()) 
    3112             param_max = str(self._model_model.item(row, 3+column_offset).text()) 
     3147 
     3148            try: 
     3149                param_min = str(self._model_model.item(row, 2+column_offset).text()) 
     3150                param_max = str(self._model_model.item(row, 3+column_offset).text()) 
     3151            except: 
     3152                pass 
     3153 
    31133154            param_list.append([param_name, param_checked, param_value, param_error, param_min, param_max]) 
    31143155 
     
    32003241 
    32013242                # limits 
    3202                 limit_lo = item[3] 
    3203                 context[name].append(limit_lo) 
    3204                 limit_hi = item[4] 
    3205                 context[name].append(limit_hi) 
     3243                try: 
     3244                    limit_lo = item[3] 
     3245                    context[name].append(limit_lo) 
     3246                    limit_hi = item[4] 
     3247                    context[name].append(limit_hi) 
     3248                except: 
     3249                    pass 
    32063250 
    32073251                # Polydisp 
     
    32623306                ioffset = 1 
    32633307            # min/max 
    3264             param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
    3265             self._model_model.item(row, 2+ioffset).setText(param_repr) 
    3266             param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
    3267             self._model_model.item(row, 3+ioffset).setText(param_repr) 
     3308            try: 
     3309                param_repr = GuiUtils.formatNumber(param_dict[param_name][2+ioffset], high=True) 
     3310                self._model_model.item(row, 2+ioffset).setText(param_repr) 
     3311                param_repr = GuiUtils.formatNumber(param_dict[param_name][3+ioffset], high=True) 
     3312                self._model_model.item(row, 3+ioffset).setText(param_repr) 
     3313            except: 
     3314                pass 
     3315 
    32683316            self.setFocus() 
     3317 
    32693318 
    32703319 
Note: See TracChangeset for help on using the changeset viewer.