Changeset b39debba in sasview


Ignore:
Timestamp:
Jan 2, 2017 3:10:13 AM (6 years ago)
Author:
wojciech
Children:
25594ca
Parents:
6c6aa83 (diff), c1681ea (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:

Merged with master

Files:
1 added
10 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sascalc/data_util/qsmearing.py

    rf8aa738 rd3911e3  
    4141        elif data.dqx_data == None or data.dqy_data == None: 
    4242            return None 
    43         return Pinhole2D(data) 
     43        return PySmear2D(data, model) 
    4444 
    4545    if  not hasattr(data, "dx") and not hasattr(data, "dxl")\ 
     
    142142    width = data.dx if data.dx is not None else 0 
    143143    return PySmear(Pinhole1D(q, width), model) 
     144 
     145 
     146class PySmear2D(object): 
     147    """ 
     148    Q smearing class for SAS 2d pinhole data 
     149    """ 
     150 
     151    def __init__(self, data=None, model=None): 
     152        self.data = data 
     153        self.model = model 
     154        self.accuracy = 'Low' 
     155        self.limit = 3.0 
     156        self.index = None 
     157        self.coords = 'polar' 
     158        self.smearer = True 
     159 
     160    def set_accuracy(self, accuracy='Low'): 
     161        """ 
     162        Set accuracy. 
     163 
     164        :param accuracy:  string 
     165        """ 
     166        self.accuracy = accuracy 
     167 
     168    def set_smearer(self, smearer=True): 
     169        """ 
     170        Set whether or not smearer will be used 
     171 
     172        :param smearer: smear object 
     173 
     174        """ 
     175        self.smearer = smearer 
     176 
     177    def set_data(self, data=None): 
     178        """ 
     179        Set data. 
     180 
     181        :param data: DataLoader.Data_info type 
     182        """ 
     183        self.data = data 
     184 
     185    def set_model(self, model=None): 
     186        """ 
     187        Set model. 
     188 
     189        :param model: sas.models instance 
     190        """ 
     191        self.model = model 
     192 
     193    def set_index(self, index=None): 
     194        """ 
     195        Set index. 
     196 
     197        :param index: 1d arrays 
     198        """ 
     199        self.index = index 
     200 
     201    def get_value(self): 
     202        """ 
     203        Over sampling of r_nbins times phi_nbins, calculate Gaussian weights, 
     204        then find smeared intensity 
     205        """ 
     206        if self.smearer: 
     207            res = Pinhole2D(data=self.data, index=self.index, 
     208                            nsigma=3.0, accuracy=self.accuracy, 
     209                            coords=self.coords) 
     210            val = self.model.evalDistribution(res.q_calc) 
     211            return res.apply(val) 
     212        else: 
     213            index = self.index if self.index is not None else slice(None) 
     214            qx_data = self.data.qx_data[index] 
     215            qy_data = self.data.qy_data[index] 
     216            q_calc = [qx_data, qy_data] 
     217            val = self.model.evalDistribution(q_calc) 
     218            return val 
     219 
  • src/sas/sascalc/fit/AbstractFitEngine.py

    rfc18690 rd3911e3  
    359359        if self.smearer != None: 
    360360            fn.set_index(self.idx) 
    361             # Get necessary data from self.data and set the data for smearing 
    362             fn.get_data() 
    363  
    364361            gn = fn.get_value() 
    365362        else: 
  • src/sas/sasgui/guiframe/gui_manager.py

    r62243ae rb39debba  
    19951995                wx.PostEvent(self, 
    19961996                             StatusEvent(status="Completed saving.")) 
    1997             except: 
     1997            except Exception: 
    19981998                msg = "Error occurred while saving: " 
     1999                msg += traceback.format_exc() 
    19992000                msg += "To save, the application panel should have a data set.." 
    20002001                wx.PostEvent(self, StatusEvent(status=msg)) 
     
    20452046                logging.warning(msg) 
    20462047                wx.PostEvent(self, StatusEvent(status=msg, info="error")) 
    2047         except: 
     2048        except Exception: 
    20482049            msg = "Error occurred while saving: " 
     2050            msg += traceback.format_exc() 
    20492051            msg += "To save, at least one application panel " 
    20502052            msg += "should have a data set.." 
  • src/sas/sasgui/perspectives/fitting/basepage.py

    r06a4306 r505706a  
    10411041                        disp_model = POLYDISPERSITY_MODELS['array']() 
    10421042                        if hasattr(state, "values") and \ 
    1043                                  self.disp_cb_dict[item].GetValue() is True: 
     1043                                 self.disp_cb_dict[item].GetValue(): 
    10441044                            if len(state.values) > 0: 
    10451045                                self.values = state.values 
     
    15411541                        index_data = ((self.qmin_x <= self.data.x) & 
    15421542                                      (self.data.x <= self.qmax_x)) 
    1543                         val = self.data.x[index_data is True] 
    1544                         val = len(val) if isinstance(val, list) else 1 
    1545                         self.Npts_fit.SetValue(str(val)) 
    1546  
     1543                        val = str(len(self.data.x[index_data])) 
     1544                        self.Npts_fit.SetValue(val) 
    15471545                    else: 
    15481546                        # No data in the panel 
     
    21472145                flag = False 
    21482146            else: 
    2149                 self.Npts_fit.SetValue(str(len(index_data[index_data is True]))) 
     2147                self.Npts_fit.SetValue(str(len(index_data[index_data]))) 
    21502148                self.fitrange = True 
    21512149 
     
    21822180                flag = False 
    21832181            else: 
    2184                 val = index_data[index_data is True] 
    2185                 val = len(val) if isinstance(val, list) else 1 
    2186                 self.Npts_fit.SetValue(str(val)) 
     2182                self.Npts_fit.SetValue(str(len(index_data[index_data]))) 
    21872183                self.fitrange = True 
    21882184 
     
    26282624            Layout after self._draw_model 
    26292625        """ 
    2630         if ON_MAC is True: 
     2626        if ON_MAC: 
    26312627            time.sleep(1) 
    26322628 
  • src/sas/sasgui/perspectives/fitting/fitpage.py

    rbf44249e r24fd27a  
    16181618                return 
    16191619        # check if it is pinhole smear and get min max if it is. 
    1620         if data.dx is not None and not numpy.any(data.dx): 
     1620        if data.dx is not None and numpy.any(data.dx): 
    16211621            self.smear_type = "Pinhole" 
    16221622            self.dq_l = data.dx[0] 
  • src/sas/sasgui/perspectives/fitting/model_thread.py

    r286c757 rc1681ea  
    8282            fn.set_model(self.model) 
    8383            fn.set_index(index_model) 
    84             # Get necessary data from self.data and set the data for smearing 
    85             fn.get_data() 
    8684            # Calculate smeared Intensity 
    8785            #(by Gaussian averaging): DataLoader/smearing2d/Smearer2D() 
     
    8987        else: 
    9088            # calculation w/o smearing 
    91             value = self.model.evalDistribution(\ 
    92                 [self.data.qx_data[index_model], 
    93                  self.data.qy_data[index_model]]) 
     89            value = self.model.evalDistribution([ 
     90                self.data.qx_data[index_model], 
     91                self.data.qy_data[index_model] 
     92            ]) 
    9493        output = numpy.zeros(len(self.data.qx_data)) 
    9594        # output default is None 
     
    198197            output[index] = self.model.evalDistribution(self.data.x[index]) 
    199198 
    200         sq_model = None 
    201         pq_model = None 
     199        sq_values = None 
     200        pq_values = None 
     201        s_model = None 
     202        p_model = None 
    202203        if isinstance(self.model, MultiplicationModel): 
    203             sq_model = numpy.zeros((len(self.data.x))) 
    204             pq_model = numpy.zeros((len(self.data.x))) 
    205             sq_model[index] = self.model.s_model.evalDistribution(self.data.x[index]) 
    206             pq_model[index] = self.model.p_model.evalDistribution(self.data.x[index]) 
     204            s_model = self.model.s_model 
     205            p_model = self.model.p_model 
     206        elif hasattr(self.model, "get_composition_models"): 
     207            p_model, s_model = self.model.get_composition_models() 
     208 
     209        if p_model is not None and s_model is not None: 
     210            sq_values = numpy.zeros((len(self.data.x))) 
     211            pq_values = numpy.zeros((len(self.data.x))) 
     212            sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
     213            pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
    207214 
    208215        elapsed = time.time() - self.starttime 
     
    221228                      unsmeared_data=unsmeared_data, 
    222229                      unsmeared_error=unsmeared_error, 
    223                       pq_model=pq_model, 
    224                       sq_model=sq_model) 
     230                      pq_model=pq_values, 
     231                      sq_model=sq_values) 
    225232 
    226233    def results(self): 
  • sasview/custom_config.py

    r79492222 r62243ae  
    1515TOOLBAR_SHOW = True 
    1616DEFAULT_PERSPECTIVE = "Fitting" 
     17SAS_OPENCL = None 
  • sasview/local_config.py

    r49e000b r62243ae  
    140140UPDATE_TIMEOUT = 2 
    141141 
     142#OpenCL option 
     143SAS_OPENCL = None 
     144 
    142145def printEVT(message): 
    143146    if __EVT_DEBUG__: 
  • src/sas/sasgui/guiframe/startup_configuration.py

    rd85c194 r62243ae  
    3131                   'CLEANUP_PLOT':False, 
    3232                   'DEFAULT_PERSPECTIVE':'Fitting', 
    33                    'DEFAULT_OPEN_FOLDER': None} 
     33                   'DEFAULT_OPEN_FOLDER': None, 
     34                   'SAS_OPENCL': None} 
    3435try: 
    3536    CURRENT_STRINGS = {'GUIFRAME_WIDTH':CURRENT.GUIFRAME_WIDTH, 
     
    4546                       'CLEANUP_PLOT':CURRENT.CLEANUP_PLOT, 
    4647                       'DEFAULT_PERSPECTIVE':CURRENT.DEFAULT_PERSPECTIVE, 
    47                        'DEFAULT_OPEN_FOLDER':CURRENT.DEFAULT_OPEN_FOLDER} 
     48                       'DEFAULT_OPEN_FOLDER':CURRENT.DEFAULT_OPEN_FOLDER, 
     49                       'SAS_OPENCL': None} 
    4850except: 
    4951    CURRENT_STRINGS = DEFAULT_STRINGS 
  • src/sas/sasgui/perspectives/fitting/fitting.py

    r06a4306 r33844bf  
    4545from sas.sasgui.guiframe.gui_manager import MDIFrame 
    4646from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     47from sas.sasgui.perspectives.fitting.gpu_options import GpuOptions 
    4748 
    4849from . import models 
     
    192193        self.bumps_options_menu = self.menu1.FindItemById(self.id_bumps_options) 
    193194        self.bumps_options_menu.Enable(True) 
     195 
     196        self.id_gpu_options_panel = wx.NewId() 
     197        self.menu1.Append(self.id_gpu_options_panel, "OpenCL Options", "Choose OpenCL driver or turn it off") 
     198        wx.EVT_MENU(owner, self.id_gpu_options_panel, self.on_gpu_options) 
    194199 
    195200        self.id_result_panel = wx.NewId() 
     
    801806        self.result_frame.Show() 
    802807        self.result_frame.Raise() 
     808 
     809    def on_gpu_options(self, event=None): 
     810        """ 
     811        Make the Fit Results panel visible. 
     812        """ 
     813        dialog = GpuOptions(None, wx.ID_ANY, "") 
     814        dialog.Show() 
    803815 
    804816    def stop_fit(self, uid): 
Note: See TracChangeset for help on using the changeset viewer.