Changes in / [3bd0cd7:0f29fad] in sasview


Ignore:
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • run.py

    rdb05c44 r328f2ef  
    155155    # so logging can be done during initialization process too 
    156156    root = abspath(dirname(realpath(sys.argv[0]))) 
    157     addpath(joinpath(root, 'src','sas')) 
    158     from logger_config import SetupLogger 
     157 
     158    addpath(joinpath(root, 'src')) 
     159    addpath(joinpath(root, joinpath('..', 'sasmodels'))) # dependency (for loading custom_config.py during log setup) 
     160 
     161    from sas.logger_config import SetupLogger 
    159162    logger = SetupLogger(__name__).config_development() 
    160163 

  • src/sas/logger_config.py

    re4335ae r799963c  
    77 
    88import pkg_resources 
     9 
     10from sas import get_custom_config 
    911 
    1012''' 
    … …  
    3941        logging.captureWarnings(True) 
    4042 
     43        self._disable_debug_from_config() 
     44 
    4145        return logger 
     46 
     47    def _disable_debug_from_config(self): 
     48        '''disable DEBUG logs as per user configuration (DEBUG logs disabled by default)''' 
     49        disable_debug = True 
     50        custom_config = get_custom_config() 
     51 
     52        if hasattr(custom_config, "FILTER_DEBUG_LOGS"): 
     53            if type(custom_config.FILTER_DEBUG_LOGS) is bool: 
     54                disable_debug = custom_config.FILTER_DEBUG_LOGS 
     55            else: 
     56                logging.warning("FILTER_DEBUG_LOGS has invalid value in custom_config.py") 
     57 
     58        if disable_debug: 
     59            # logging.info("Note: DEBUG logs are disabled.") 
     60            logging.disable(logging.DEBUG) 
    4261 
    4362    def _read_config_file(self): 

  • src/sas/qtgui/MainWindow/DataExplorer.py

    rc7f259d r4bf58293  
    44import time 
    55import logging 
     6import re 
    67 
    78from PyQt5 import QtCore 
    … …  
    3637    # The controller which is responsible for managing signal slots connections 
    3738    # for the gui and providing an interface to the data model. 
     39 
     40    # This matches the ID of a plot created using FittingLogic._create1DPlot, e.g. 
     41    # "5 [P(Q)] modelname" 
     42    # or 
     43    # "4 modelname". 
     44    # Useful for determining whether the plot in question is for an intermediate result, such as P(Q) or S(Q) in the 
     45    # case of a product model; the identifier for this is held in square brackets, as in the example above. 
     46    theory_plot_ID_pattern = re.compile(r"^([0-9]+)\s+(\[(.*)\]\s+)?(.*)$") 
    3847 
    3948    def __init__(self, parent=None, guimanager=None, manager=None): 
    … …  
    525534                self.active_plots[plot_id].replacePlot(plot_id, plot) 
    526535            else: 
     536                # Don't plot intermediate results, e.g. P(Q), S(Q) 
     537                match = self.theory_plot_ID_pattern.match(plot_id) 
     538                # 2nd match group contains the identifier for the intermediate result, if present (e.g. "[P(Q)]") 
     539                if match and match.groups()[1] != None: 
     540                    continue 
    527541                # 'sophisticated' test to generate standalone plot for residuals 
    528542                if 'esiduals' in plot.title: 
    … …  
    12401254            #if current_tab_name in self.theory_model.item(current_index).text(): 
    12411255            if current_tab_name == self.theory_model.item(current_index).text(): 
    1242                 return 
    12431256                self.theory_model.removeRow(current_index) 
    12441257                break 

  • src/sas/qtgui/MainWindow/DataManager.py

    r0261bc1 r4e255d1  
    2424import json 
    2525import time 
    26 from io import StringIO 
     26from io import BytesIO 
    2727import numpy as np 
    2828 
    … …  
    368368            # ndarray 
    369369            if isinstance(o, np.ndarray): 
    370                 buffer = StringIO() 
     370                buffer = BytesIO() 
    371371                np.save(buffer, o) 
    372372                buffer.seek(0) 
    … …  
    435435            # ndarray 
    436436            if cls == np.ndarray: 
    437                 buffer = StringIO() 
     437                buffer = BytesIO() 
    438438                buffer.write(data['data'].encode('latin-1')) 
    439439                buffer.seek(0) 

  • src/sas/qtgui/Perspectives/Fitting/FittingLogic.py

    r87dfca4 rb4d05bd  
    132132        self._data.ymax = ymax 
    133133 
    134     def new1DPlot(self, return_data, tab_id): 
    135         """ 
    136         Create a new 1D data instance based on fitting results 
    137         """ 
    138         # Unpack return data from Calc1D 
    139         x, y, page_id, state, weight,\ 
    140         fid, toggle_mode_on, \ 
    141         elapsed, index, model,\ 
    142         data, update_chisqr, source = return_data 
    143  
     134    def _create1DPlot(self, tab_id, x, y, model, data, component=None): 
     135        """ 
     136        For internal use: create a new 1D data instance based on fitting results. 
     137        'component' is a string indicating the model component, e.g. "P(Q)" 
     138        """ 
    144139        # Create the new plot 
    145140        new_plot = Data1D(x=x, y=y) 
    … …  
    150145 
    151146        new_plot.group_id = data.group_id 
    152         new_plot.id = str(tab_id) + " " + model.id 
    153  
    154         if data.filename: 
    155             new_plot.name = model.name + " [" + data.filename + "]" # data file 
    156         else: 
    157             new_plot.name = model.name + " [" + model.id + "]"  # theory 
     147        new_plot.id = str(tab_id) + " " + ("[" + component + "] " if component else "") + model.id 
     148 
     149        # use data.filename for data, use model.id for theory 
     150        id_str = data.filename if data.filename else model.id 
     151        new_plot.name = model.name + ((" " + component) if component else "") + " [" + id_str + "]" 
    158152 
    159153        new_plot.title = new_plot.name 
    … …  
    162156 
    163157        return new_plot 
     158 
     159    def new1DPlot(self, return_data, tab_id): 
     160        """ 
     161        Create a new 1D data instance based on fitting results 
     162        """ 
     163        # Unpack return data from Calc1D 
     164        x, y, page_id, state, weight,\ 
     165        fid, toggle_mode_on, \ 
     166        elapsed, index, model, \ 
     167        data, update_chisqr, source, \ 
     168        unsmeared_output, unsmeared_data, unsmeared_error, \ 
     169        pq_values, sq_values = return_data 
     170 
     171        return self._create1DPlot(tab_id, x, y, model, data) 
    164172 
    165173    def new2DPlot(self, return_data): 
    … …  
    205213        return new_plot 
    206214 
     215    def new1DProductPlots(self, return_data, tab_id): 
     216        """ 
     217        If return_data contains separated P(Q) and/or S(Q) data, create 1D plots for each and return as the tuple 
     218        (pq_plot, sq_plot). If either are unavailable, the corresponding plot is None. 
     219        """ 
     220        # Unpack return data from Calc1D 
     221        x, y, page_id, state, weight, \ 
     222        fid, toggle_mode_on, \ 
     223        elapsed, index, model, \ 
     224        data, update_chisqr, source, \ 
     225        unsmeared_output, unsmeared_data, unsmeared_error, \ 
     226        pq_values, sq_values = return_data 
     227 
     228        pq_plot = None 
     229        sq_plot = None 
     230 
     231        if pq_values is not None: 
     232            pq_plot = self._create1DPlot(tab_id, x, pq_values, model, data, component="P(Q)") 
     233        if sq_values is not None: 
     234            sq_plot = self._create1DPlot(tab_id, x, sq_values, model, data, component="S(Q)") 
     235 
     236        return pq_plot, sq_plot 
     237 
    207238    def computeDataRange(self): 
    208239        """ 

  • src/sas/qtgui/Perspectives/Fitting/FittingWidget.py

    r10fee37 rb4d05bd  
    21132113            self.updateModelIndex(fitted_data) 
    21142114        else: 
    2115             name = self.nameForFittedData(self.kernel_module.id) 
     2115            if not fitted_data.name: 
     2116                name = self.nameForFittedData(self.kernel_module.id) 
     2117            else: 
     2118                name = fitted_data.name 
    21162119            fitted_data.title = name 
    2117             fitted_data.name = name 
    21182120            fitted_data.filename = name 
    21192121            fitted_data.symbol = "Line" 
    … …  
    22292231        self.model_data = fitted_data 
    22302232 
     2233        # Create plots for intermediate product data 
     2234        pq_data, sq_data = self.logic.new1DProductPlots(return_data, self.tab_id) 
     2235        if pq_data is not None: 
     2236            pq_data.symbol = "Line" 
     2237            self.createNewIndex(pq_data) 
     2238        if sq_data is not None: 
     2239            sq_data.symbol = "Line" 
     2240            self.createNewIndex(sq_data) 
     2241 
    22312242    def complete2D(self, return_data): 
    22322243        """ 

  • src/sas/qtgui/Perspectives/Fitting/ModelThread.py

    rd4dac80 r3ae9179  
    222222            s_model = self.model.s_model 
    223223            p_model = self.model.p_model 
    224         elif hasattr(self.model, "get_composition_models"): 
    225             p_model, s_model = self.model.get_composition_models() 
    226  
    227         if p_model is not None and s_model is not None: 
    228             sq_values = numpy.zeros((len(self.data.x))) 
    229             pq_values = numpy.zeros((len(self.data.x))) 
    230             sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
    231             pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
     224        elif hasattr(self.model, "calc_composition_models"): 
     225            results = self.model.calc_composition_models(self.data.x[index]) 
     226            if results is not None: 
     227                pq_values, sq_values = results 
     228 
     229        if pq_values is None or sq_values is None: 
     230            if p_model is not None and s_model is not None: 
     231                sq_values = numpy.zeros((len(self.data.x))) 
     232                pq_values = numpy.zeros((len(self.data.x))) 
     233                sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
     234                pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
    232235 
    233236        elapsed = time.time() - self.starttime 
    … …  
    243246                    self.data, 
    244247                    self.update_chisqr, 
    245                     self.source) 
     248                    self.source, 
     249                    unsmeared_output, unsmeared_data, unsmeared_error, 
     250                    pq_values, sq_values) 
    246251        else: 
    247252            self.complete(x=self.data.x[index], y=output[index], 

  • src/sas/qtgui/Perspectives/Fitting/UnitTesting/FittingLogicTest.py

    r80468f6 re752ab8  
    100100        data.id = "poop" 
    101101        return_data = (data.x,data.y, 7, None, None, 
    102                         0, True, 0.0, 1, data, 
    103                         data, False, None) 
     102                       0, True, 0.0, 1, data, 
     103                       data, False, None, 
     104                       None, None, None, 
     105                       None, None) 
    104106 
    105107        new_plot = self.logic.new1DPlot(return_data=return_data, tab_id=0) 

  • src/sas/qtgui/Utilities/GuiUtils.py

    r685e0e3 r3933ee9  
    312312        return clone 
    313313 
     314 
     315def getMonospaceFont(): 
     316    """Convenience function; returns a monospace font to be used in any shells, code editors, etc.""" 
     317 
     318    # Note: Consolas is only available on Windows; the style hint is used on other operating systems 
     319    font = QtGui.QFont("Consolas", 10) 
     320    font.setStyleHint(QtGui.QFont.Monospace, QtGui.QFont.PreferQuality) 
     321    return font 
    314322 
    315323def createModelItemWithPlot(update_data, name=""): 

  • src/sas/qtgui/Utilities/IPythonWidget.py

    rfbfc488 r3933ee9  
    44 
    55from PyQt5 import QtSvg 
     6 
     7from sas.qtgui.Utilities import GuiUtils 
    68 
    79def new_load_qt(api_options): 
    … …  
    3537        app = guisupport.get_app_qt4() 
    3638 
     39        font = GuiUtils.getMonospaceFont() 
     40        self.font = font 
     41 
    3742        # Create an in-process kernel 
    3843        kernel_manager = QtInProcessKernelManager() 

  • src/sas/qtgui/Utilities/ModelEditor.py

    r26970b3 r3933ee9  
    33 
    44from sas.qtgui.Utilities.UI.ModelEditor import Ui_ModelEditor 
     5from sas.qtgui.Utilities import GuiUtils 
    56 
    67class ModelEditor(QtWidgets.QDialog, Ui_ModelEditor): 
    … …  
    3031        self.highlight = PythonHighlighter(self.txtEditor.document()) 
    3132 
     33        self.txtEditor.setFont(GuiUtils.getMonospaceFont()) 
     34 
    3235    def addSignals(self): 
    3336        """ 

  • src/sas/qtgui/Utilities/PluginDefinition.py

    r060413c r3933ee9  
    44 
    55from sas.qtgui.Utilities.UI.PluginDefinitionUI import Ui_PluginDefinition 
     6from sas.qtgui.Utilities import GuiUtils 
    67 
    78# txtName 
    … …  
    6465""" 
    6566        self.txtFunction.insertPlainText(text) 
     67        self.txtFunction.setFont(GuiUtils.getMonospaceFont()) 
    6668 
    6769        # Validators 

  • src/sas/sasview/custom_config.py

    refe730d r799963c  
    1616DEFAULT_PERSPECTIVE = "Fitting" 
    1717SAS_OPENCL = "None" 
     18 
     19# Logging options 
     20FILTER_DEBUG_LOGS = True 
Note: See TracChangeset for help on using the changeset viewer.