Changeset f72333f in sasview


Ignore:
Timestamp:
May 10, 2010 6:50:05 PM (15 years ago)
Author:
Jae Cho <jhjcho@…>
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, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
4fbc93e
Parents:
2d409fa
Message:

Plugged in 2D smear: traditional over-sampling method

Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed

  • DataLoader/qsmearing.py

    r4834cba rf72333f  
    1313import math 
    1414import logging, sys 
     15from DataLoader.smearing_2d import Smearer2D 
    1516 
    1617def smear_selection(data1D): 
    … …  
    3435    # object, just return None 
    3536    if  data1D.__class__.__name__ != 'Data1D': 
    36         return None 
     37        if data1D == None: 
     38            return None 
     39        elif data1D.dqx_data == None or data1D.dqy_data == None: 
     40            return None 
     41        return Smearer2D(data1D) 
    3742     
    3843    if  not hasattr(data1D, "dx") and not hasattr(data1D, "dxl") and not hasattr(data1D, "dxw"): 

  • park_integration/AbstractFitEngine.py

    r36bc34e rf72333f  
    261261        self.qmin= None 
    262262        self.qmax= None 
     263        self.smearer = None 
    263264        self.set_data(sans_data2d ) 
     265 
    264266         
    265267    def set_data(self, sans_data2d, qmin=None, qmax=None ): 
    … …  
    294296        self.index_model = (self.index_model) & (self.mask) 
    295297        self.index_model = (self.index_model) & (numpy.isfinite(self.data)) 
    296             
     298         
     299    def set_smearer(self,smearer):   
     300        """ 
     301            Set smearer 
     302        """ 
     303        if smearer == None: 
     304            return 
     305        self.smearer = smearer 
     306        self.smearer.set_index(self.index_model) 
     307        self.smearer.get_data() 
     308 
    297309    def setFitRange(self,qmin=None,qmax=None): 
    298310        """ to set the fit range""" 
    … …  
    317329        """ 
    318330            @return the residuals 
    319         """         
     331        """  
     332        if self.smearer != None: 
     333            fn.set_index(self.index_model) 
     334            # Get necessary data from self.data and set the data for smearing 
     335            fn.get_data() 
     336 
     337            gn = fn.get_value()   
     338        else: 
     339            gn = fn([self.qx_data[self.index_model],self.qy_data[self.index_model]]) 
    320340        # use only the data point within ROI range 
    321         res=(self.data[self.index_model] - fn([self.qx_data[self.index_model], 
    322                              self.qy_data[self.index_model]]))/self.res_err_data[self.index_model] 
     341        res=(self.data[self.index_model] - gn)/self.res_err_data[self.index_model] 
    323342        return res 
    324343         

  • sansview/perspectives/fitting/basepage.py

    r65b77529 rf72333f  
    1414(PreviousStateEvent, EVT_PREVIOUS_STATE)   = wx.lib.newevent.NewEvent() 
    1515(NextStateEvent, EVT_NEXT_STATE)   = wx.lib.newevent.NewEvent() 
     16 
    1617_BOX_WIDTH = 76 
    1718_QMIN_DEFAULT = 0.001 
    … …  
    5556        self.data = None 
    5657        self.mask = None 
     58        self.theory = None 
    5759        self.state = PageState(parent=parent) 
    5860        ## dictionary containing list of models 
    … …  
    136138        #self.onSave(event=None) 
    137139        self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu) 
    138          
     140 
    139141        ## create the basic structure of the panel with empty sizer 
    140142        self.define_page_structure() 
    … …  
    10971099                        flag = self.update_pinhole_smear() 
    10981100                    else: 
    1099                         self.manager.set_smearer(smearer=temp_smearer, qmin= float(self.qmin_x), 
     1101                        self.manager.set_smearer_nodraw(smearer=temp_smearer, qmin= float(self.qmin_x), 
    11001102                                                 qmax= float(self.qmax_x)) 
    11011103                elif not is_2Ddata: 
    … …  
    13621364                    temp_smear= self.current_smearer 
    13631365             
    1364             self.manager.draw_model(self.model, data=self.data, 
     1366            self.manager.draw_model(self.model,  
     1367                                    data=self.data, 
    13651368                                    smearer= temp_smear, 
    13661369                                    qmin=float(self.qmin_x),  
    13671370                                    qmax=float(self.qmax_x), 
    13681371                                    qstep= float(self.num_points), 
    1369                                     enable2D=self.enable2D)  
    1370         
     1372                                    enable2D=self.enable2D) 
    13711373         
    13721374    def _set_model_sizer(self,sizer, box_sizer, title="", object=None): 
    … …  
    15071509            item must model class 
    15081510        """ 
     1511        st = time.time() 
    15091512        for models in list: 
    15101513            model= models() 
    … …  
    15141517                    name = model.name 
    15151518                combobox.Append(name,models) 
    1516       
     1519 
    15171520        return 0 
    15181521 
    … …  
    16291632            self.structurebox.Enable() 
    16301633            self.text2.Enable() 
    1631         if self.data.__class__.__name__ =="Data2D": 
    1632             self.smear_description_2d.Show(True) 
     1634        #if self.data.__class__.__name__ =="Data2D": 
     1635            #self.smear_description_2d.Show(True) 
    16331636             
    16341637        s_id = self.structurebox.GetCurrentSelection() 
    … …  
    21522155        if ON_MAC == True: 
    21532156            time.sleep(1) 
    2154               
     2157             
     2158 
    21552159    def on_reset_clicked(self,event): 
    21562160        """ 
    … …  
    21672171            self.qmin_x = data_min 
    21682172            self.qmax_x = math.sqrt(x*x + y*y) 
     2173            # check smearing 
     2174            if not self.disable_smearer.GetValue(): 
     2175                temp_smearer= self.current_smearer 
     2176                ## set smearing value whether or not the data contain the smearing info 
     2177                if self.pinhole_smearer.GetValue(): 
     2178                    flag = self.update_pinhole_smear() 
     2179                else: 
     2180                    flag = True 
    21692181        elif self.data.__class__.__name__ != "Data2D": 
    21702182            self.qmin_x = min(self.data.x) 
    … …  
    22052217        #reset the q range values 
    22062218        self._reset_plotting_range(self.state) 
    2207         self.compute_chisqr(smearer=self.current_smearer) 
     2219        #self.compute_chisqr(smearer=self.current_smearer) 
    22082220        #Re draw plot 
    22092221        self._draw_model() 

  • sansview/perspectives/fitting/fitpage.py

    r2d409fa rf72333f  
    2020(FitterTypeEvent, EVT_FITTER_TYPE)   = wx.lib.newevent.NewEvent() 
    2121(FitStopEvent, EVT_FIT_STOP)   = wx.lib.newevent.NewEvent() 
     22(Chi2UpdateEvent, EVT_CHI2_UPDATE)   = wx.lib.newevent.NewEvent() 
    2223_BOX_WIDTH = 76 
    2324_DATA_BOX_WIDTH = 300 
    … …  
    5455        self.smearer = None 
    5556        self.current_smearer = None 
     57        ## 2D smear accuracy default 
     58        self.smear2d_accuracy = 'Low' 
     59        ## slit smear:  
    5660        self.dxl = None 
    5761        self.dxw = None 
     62        ## pinhole smear  
    5863        self.dx_min = None 
    5964        self.dx_max = None 
    6065         
     66        ## model data (theory) calculated on drawing. 
     67        self.theory_data = None 
     68       
    6169        ## draw sizer 
    6270        self._fill_datainfo_sizer() 
    … …  
    7886            if self.smearer ==None: 
    7987                self.enable_smearer.Disable() 
    80             if self.data.__class__.__name__ =="Data2D": 
    81                 if self.model != None: 
    82                     self.smear_description_2d.Show(True) 
     88            #if self.data.__class__.__name__ =="Data2D": 
     89                #if self.model != None: 
     90                    #self.smear_description_2d.Show(True) 
    8391                     
    8492        self.disp_cb_dict = {} 
    … …  
    8694        self.Bind(EVT_FITTER_TYPE,self._on_engine_change) 
    8795        self.Bind(EVT_FIT_STOP,self._on_fit_complete) 
    88          
     96        self.Bind(EVT_CHI2_UPDATE, self.on_complete_chisqr) 
    8997 
    9098    def _on_fit_complete(self, event): 
    … …  
    97105        pass 
    98106         
    99          
     107    def _is_2D(self): 
     108        """ 
     109            Check if data_name is Data2D 
     110            @return: True or False 
     111        """ 
     112         
     113        if self.data.__class__.__name__ =="Data2D": 
     114            return True 
     115        return False 
     116             
    100117    def _on_engine_change(self, event): 
    101118        """ 
    … …  
    182199        smear_message_none  =  "No smearing is selected..." 
    183200        smear_message_dqdata  =  "The dQ data is being used for smearing..." 
    184         smear_message_2d  =  "No smearing is supported for 2D model fitting..." 
     201        smear_message_2d  =  "Higher accuracy is very time-expensive. Use it with care..." 
    185202        smear_message_new_ssmear  =  "Please enter only the value of interest to customize smearing..." 
    186203        smear_message_new_psmear  =  "Please enter both; the dQ will be generated by interpolation..." 
    187         smear_message_pinhole_min_title = "dQ_min[1/A]:" 
    188         smear_message_pinhole_max_title = "dQ_max[1/A]:" 
     204        smear_message_2d_x_title = "<dQx>[1/A]:" 
     205        smear_message_2d_y_title = "<dQy>[1/A]:" 
     206        smear_message_pinhole_min_title = "dQ_low[1/A]:" 
     207        smear_message_pinhole_max_title = "dQ_high[1/A]:" 
    189208        smear_message_slit_height_title = "Slit height[1/A]:" 
    190209        smear_message_slit_width_title = "Slit width[1/A]:" 
    … …  
    205224        sizer_fit = wx.GridSizer(2, 4,2,6) 
    206225         
     226        # combobox for smear2d accuracy selection 
     227        self.smear_accuracy = wx.ComboBox(self, -1,size=(50,-1),style=wx.CB_READONLY) 
     228        self._set_accuracy_list() 
     229        self.smear_accuracy.SetValue(self.smear2d_accuracy) 
     230        self.smear_accuracy.SetSelection(0) 
     231        self.smear_accuracy.SetToolTipString("'Higher' uses more Gaussian points for smearing computation.") 
     232                    
     233         
     234              
     235        wx.EVT_COMBOBOX(self.smear_accuracy,-1, self._on_select_accuracy) 
     236 
    207237        #Fit button 
    208238        self.btFit = wx.Button(self,wx.NewId(),'Fit', size=(88,25)) 
    … …  
    210240        self.btFit.SetToolTipString("Start fitting.") 
    211241         
    212         #textcntrl for new resolution 
    213         self.smear_pinhole_max = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-20,20),style=wx.TE_PROCESS_ENTER, 
     242        #textcntrl for custom resolution 
     243        self.smear_pinhole_max = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER, 
    214244                                            text_enter_callback = self.onPinholeSmear) 
    215         self.smear_pinhole_min = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-20,20),style=wx.TE_PROCESS_ENTER, 
     245        self.smear_pinhole_min = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER, 
    216246                                            text_enter_callback = self.onPinholeSmear) 
    217         self.smear_slit_height= self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-20,20),style=wx.TE_PROCESS_ENTER, 
     247        self.smear_slit_height= self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER, 
    218248                                            text_enter_callback = self.onSlitSmear) 
    219         self.smear_slit_width = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-20,20),style=wx.TE_PROCESS_ENTER, 
     249        self.smear_slit_width = self.ModelTextCtrl(self, -1,size=(_BOX_WIDTH-25,20),style=wx.TE_PROCESS_ENTER, 
    220250                                            text_enter_callback = self.onSlitSmear) 
    221         self.smear_data_left= BGTextCtrl(self, -1, size=(_BOX_WIDTH-20,20), style=0) 
     251 
     252        ## smear 
     253        self.smear_data_left= BGTextCtrl(self, -1, size=(_BOX_WIDTH-25,20), style=0) 
    222254        self.smear_data_left.SetValue(str(self.dq_l)) 
    223         self.smear_data_right = BGTextCtrl(self, -1, size=(_BOX_WIDTH-20,20), style=0) 
     255        self.smear_data_right = BGTextCtrl(self, -1, size=(_BOX_WIDTH-25,20), style=0) 
    224256        self.smear_data_right.SetValue(str(self.dq_r)) 
    225257 
    226         #set default values 
     258        #set default values for smear 
    227259        self.smear_pinhole_max.SetValue(str(self.dx_max)) 
    228260        self.smear_pinhole_min.SetValue(str(self.dx_min)) 
    … …  
    281313        self.smear_description_dqdata    =  wx.StaticText(self, -1, smear_message_dqdata , style=wx.ALIGN_LEFT) 
    282314        self.smear_description_type    =  wx.StaticText(self, -1, "Type:" , style=wx.ALIGN_LEFT) 
    283         self.smear_description_smear_type    =  BGTextCtrl(self, -1, size=(45,20), style=0) 
     315        self.smear_description_accuracy_type    =  wx.StaticText(self, -1, "Accuracy:" , style=wx.ALIGN_LEFT) 
     316        self.smear_description_smear_type    =  BGTextCtrl(self, -1, size=(57,20), style=0) 
    284317        self.smear_description_smear_type.SetValue(str(self.dq_l)) 
    285318        self.SetBackgroundColour(self.GetParent().GetBackgroundColour()) 
    … …  
    287320        self.smear_message_new_s = wx.StaticText(self, -1, smear_message_new_ssmear  , style=wx.ALIGN_LEFT) 
    288321        self.smear_message_new_p = wx.StaticText(self, -1, smear_message_new_psmear  , style=wx.ALIGN_LEFT) 
     322        self.smear_description_2d_x     =  wx.StaticText(self, -1, smear_message_2d_x_title  , style=wx.ALIGN_LEFT) 
     323        self.smear_description_2d_y     =  wx.StaticText(self, -1, smear_message_2d_y_title  , style=wx.ALIGN_LEFT) 
    289324        self.smear_description_pin_min     =  wx.StaticText(self, -1, smear_message_pinhole_min_title  , style=wx.ALIGN_LEFT) 
    290325        self.smear_description_pin_max     =  wx.StaticText(self, -1, smear_message_pinhole_max_title  , style=wx.ALIGN_LEFT) 
    … …  
    300335        self.sizer_set_smearer.Add( self.smear_description_2d,0, wx.CENTER, 10 ) 
    301336        self.sizer_new_smear.Add( self.smear_description_type,0, wx.CENTER, 10 ) 
     337        self.sizer_new_smear.Add( self.smear_description_accuracy_type,0, wx.CENTER, 10 ) 
     338        self.sizer_new_smear.Add( self.smear_accuracy ) 
    302339        self.sizer_new_smear.Add( self.smear_description_smear_type,0, wx.CENTER, 10 ) 
    303340        self.sizer_new_smear.Add((15,-1)) 
     341        self.sizer_new_smear.Add( self.smear_description_2d_x,0, wx.CENTER, 10 ) 
    304342        self.sizer_new_smear.Add( self.smear_description_pin_min,0, wx.CENTER, 10 ) 
    305343        self.sizer_new_smear.Add( self.smear_description_slit_height,0, wx.CENTER, 10 ) 
     344 
    306345        self.sizer_new_smear.Add( self.smear_pinhole_min,0, wx.CENTER, 10 ) 
    307346        self.sizer_new_smear.Add( self.smear_slit_height,0, wx.CENTER, 10 ) 
    308347        self.sizer_new_smear.Add( self.smear_data_left,0, wx.CENTER, 10 ) 
    309348        self.sizer_new_smear.Add((20,-1)) 
     349        self.sizer_new_smear.Add( self.smear_description_2d_y,0, wx.CENTER, 10 ) 
    310350        self.sizer_new_smear.Add( self.smear_description_pin_max,0, wx.CENTER, 10 ) 
    311351        self.sizer_new_smear.Add( self.smear_description_slit_width,0, wx.CENTER, 10 ) 
     352 
    312353        self.sizer_new_smear.Add( self.smear_pinhole_max,0, wx.CENTER, 10 ) 
    313354        self.sizer_new_smear.Add( self.smear_slit_width,0, wx.CENTER, 10 ) 
    … …  
    336377                self.enable_smearer.Disable()   
    337378            else: 
    338                 self.smear_description_2d.Show(True)  
    339                 self.pinhole_smearer.Disable()  
     379                self.smear_description_none.Show(True) 
     380                #self.smear_description_2d.Show(True)  
     381                #self.pinhole_smearer.Disable()  
    340382                self.slit_smearer.Disable()    
    341                 self.enable_smearer.Disable()  
     383                #self.enable_smearer.Disable()  
    342384        else: self._show_smear_sizer() 
    343385        boxsizer_range.Add(self.sizer_set_masking) 
    … …  
    811853                if self.enable_smearer.GetValue(): 
    812854                    temp_smear= self.smearer 
    813                 self.compute_chisqr(temp_smear) 
     855                #self.compute_chisqr(temp_smear) 
    814856            except: 
    815857                ## error occured on chisqr computation 
    … …  
    864906                                                             qmax= float(self.qmax_x))  
    865907                if flag:    
    866                     self.compute_chisqr(smearer= temp_smearer) 
     908                    #self.compute_chisqr(smearer= temp_smearer) 
    867909         
    868910                    ## new state posted 
    … …  
    9751017           wx.PostEvent(self.parent.parent, StatusEvent(status = msg )) 
    9761018         
    977         self.compute_chisqr()    
     1019        self._draw_model() 
     1020        ##update chi2 
     1021        #self.compute_chisqr(smearer= temp_smearer) 
    9781022        #self._undo.Enable(True) 
    9791023        self.save_current_state() 
    … …  
    9811025        wx.PostEvent(self.parent, event) 
    9821026        self.state_change= False 
    983         self._draw_model() 
     1027 
    9841028        return 
    9851029    def _clear_Err_on_Fit(self): 
    … …  
    10461090        self.dq_l = None 
    10471091        self.dq_r = None 
    1048          
    1049         if self.data is None or\ 
    1050                 self.data.__class__.__name__ == 'Data2D':            
     1092        data = self.data 
     1093        if self.data is None: 
    10511094            return 
    1052  
    1053         data = self.data 
     1095        elif self.data.__class__.__name__ == 'Data2D':   
     1096            if data.dqx_data == None or  data.dqy_data ==None:  
     1097                return 
     1098            elif self.smearer != None and all(data.dqx_data !=0)and all(data.dqy_data !=0):  
     1099                self.smear_type = "Pinhole2d" 
     1100                self.dq_l = format_number(numpy.average(data.dqx_data))  
     1101                self.dq_r = format_number(numpy.average(data.dqy_data))   
     1102                return  
     1103            else:  
     1104                return 
     1105 
     1106        
    10541107 
    10551108        # check if it is pinhole smear and get min max if it is. 
    10561109        if data.dx != None and all(data.dx !=0):  
    10571110            self.smear_type = "Pinhole"  
    1058             self.dq_l = numpy.min(data.dx) 
    1059             self.dq_r = numpy.max(data.dx) 
     1111            self.dq_l = data.dx[0] 
     1112            self.dq_r = data.dx[-1] 
    10601113             
    10611114        # check if it is slit smear and get min max if it is. 
    … …  
    10731126            Show only the sizers depending on smear selection 
    10741127        """ 
     1128        # smear disabled 
    10751129        if self.disable_smearer.GetValue(): 
    10761130            self.smear_description_none.Show(True) 
     1131        # 2Dsmear 
     1132        elif self._is_2D(): 
     1133            self.smear_description_accuracy_type.Show(True) 
     1134            self.smear_accuracy.Show(True) 
     1135            self.smear_description_accuracy_type.Show(True) 
     1136            self.smear_description_2d.Show(True) 
     1137            self.smear_description_2d_x.Show(True) 
     1138            self.smear_description_2d_y.Show(True) 
     1139            if self.pinhole_smearer.GetValue(): 
     1140                self.smear_pinhole_min.Show(True) 
     1141                self.smear_pinhole_max.Show(True) 
     1142        # smear from data 
    10771143        elif self.enable_smearer.GetValue(): 
     1144 
    10781145            self.smear_description_dqdata.Show(True) 
    10791146            if self.smear_type != None: 
    1080                 self.smear_description_type.Show(True) 
    10811147                self.smear_description_smear_type.Show(True) 
    10821148                if self.smear_type == 'Slit': 
    10831149                    self.smear_description_slit_height.Show(True) 
    1084                     self.smear_description_slit_width.Show(True) 
     1150                    self.smear_description_slit_width.Show(True)                 
    10851151                elif self.smear_type == 'Pinhole': 
    10861152                    self.smear_description_pin_min.Show(True) 
    10871153                    self.smear_description_pin_max.Show(True) 
     1154                self.smear_description_smear_type.Show(True) 
     1155                self.smear_description_type.Show(True) 
    10881156                self.smear_data_left.Show(True) 
    10891157                self.smear_data_right.Show(True) 
     1158        # custom pinhole smear 
    10901159        elif self.pinhole_smearer.GetValue(): 
    1091             self.smear_message_new_p.Show(True) 
    1092             self.smear_description_pin_min.Show(True) 
     1160            if self.smear_type == 'Pinhole': 
     1161                self.smear_message_new_p.Show(True) 
     1162                self.smear_description_pin_min.Show(True) 
     1163                self.smear_description_pin_max.Show(True) 
     1164 
    10931165            self.smear_pinhole_min.Show(True) 
    1094             self.smear_description_pin_max.Show(True) 
    10951166            self.smear_pinhole_max.Show(True) 
     1167        # custom slit smear 
    10961168        elif self.slit_smearer.GetValue(): 
    10971169            self.smear_message_new_s.Show(True) 
    … …  
    11091181        self.smear_description_type.Hide() 
    11101182        self.smear_description_smear_type.Hide() 
     1183        self.smear_description_accuracy_type.Hide() 
     1184        self.smear_description_2d_x.Hide() 
     1185        self.smear_description_2d_y.Hide() 
    11111186        self.smear_description_2d.Hide() 
     1187         
     1188        self.smear_accuracy.Hide() 
    11121189        self.smear_data_left.Hide() 
    11131190        self.smear_data_right.Hide() 
    … …  
    11231200        self.smear_message_new_s.Hide() 
    11241201     
     1202    def _set_accuracy_list(self): 
     1203        """ 
     1204            Set the list of an accuracy in 2D custum smear: Xhigh, High, Med, or Low 
     1205        """ 
     1206        # list of accuracy choices 
     1207        list = ['Low','Med','High','Xhigh'] 
     1208        for idx in range(len(list)): 
     1209            self.smear_accuracy.Append(list[idx],idx) 
     1210             
     1211    def _on_select_accuracy(self,event): 
     1212        """ 
     1213            Select an accuracy in 2D custom smear: Xhigh, High, Med, or Low 
     1214        """ 
     1215        #event.Skip() 
     1216        accuracy = event.GetEventObject() 
     1217         
     1218        self.smear2d_accuracy = accuracy.GetValue() 
     1219        if self.pinhole_smearer.GetValue(): 
     1220            self.onPinholeSmear(event=None) 
     1221         
     1222        else:    self.onSmear(event=None) 
     1223        if self.current_smearer !=None: 
     1224                self.current_smearer.set_accuracy(accuracy = self.smear2d_accuracy) 
     1225        event.Skip() 
    11251226    def _onMask(self, event):      
    11261227        """ 
    … …  
    11361237         
    11371238    def _draw_masked_model(self,event): 
     1239        """ 
     1240        Draw model image w/mask 
     1241        """ 
    11381242        event.Skip() 
    11391243 
    … …  
    11771281            # more disables for 2D 
    11781282            if self.data.__class__.__name__ =="Data2D": 
    1179                 if self.model != None: 
    1180                     self.smear_description_2d.Show(True) 
    1181                 self.smear_description_none.Hide() 
    1182                 self.pinhole_smearer.Disable() 
    11831283                self.slit_smearer.Disable() 
    11841284                self.default_mask = copy.deepcopy(self.data.mask) 
    … …  
    14371537                            "Smear: %s"%msg)) 
    14381538            return 
     1539         
    14391540        # Need update param values 
    1440         self._update_paramv_on_fit() 
     1541        self._update_paramv_on_fit()      
     1542 
    14411543        # msg default 
    14421544        msg = None 
    … …  
    14571559        # hide all silt sizer     
    14581560        self._hide_all_smear_info() 
    1459             
     1561         
    14601562        ##Calculate chi2 
    1461         self.compute_chisqr(smearer= self.current_smearer)  
     1563        temp_smearer = self.current_smearer 
     1564        #self.compute_chisqr(smearer= temp_smearer) 
     1565             
    14621566        # show relevant slit sizers  
    14631567        self._show_smear_sizer() 
     1568 
    14641569        self.sizer_set_smearer.Layout() 
    14651570        self.Layout()    
    … …  
    15051610        # copy data 
    15061611        data = copy.deepcopy(self.data) 
    1507         data_len = len(data.x) 
    1508         data.dx = None 
    1509         data.dxl = None 
    1510         data.dxw = None 
     1612        if self._is_2D(): 
     1613            self.smear_type = 'Pinhole2d' 
     1614            len_data = len(data.data) 
     1615            data.dqx_data = numpy.zeros(len_data) 
     1616            data.dqy_data = numpy.zeros(len_data) 
     1617        else: 
     1618            self.smear_type = 'Pinhole' 
     1619            len_data = len(data.x) 
     1620            data.dx = numpy.zeros(len_data) 
     1621            data.dxl = None 
     1622            data.dxw = None 
    15111623        msg = None 
    15121624    
    1513         # make sure once more if it is smearer 
    1514         data = copy.deepcopy(self.data) 
    1515         len_data = len(data.x) 
    1516         data.dx = numpy.zeros(len_data) 
    15171625        get_pin_min = self.smear_pinhole_min 
    15181626        get_pin_max = self.smear_pinhole_max         
    15191627 
    1520         if self._validate_qrange(get_pin_min, get_pin_max ): 
     1628        if not check_float(get_pin_min): 
     1629            get_pin_min.SetBackgroundColour("pink") 
     1630            msg= "Model Error:wrong value entered!!!" 
     1631        elif not check_float(get_pin_max ): 
     1632            get_pin_max.SetBackgroundColour("pink") 
     1633            msg= "Model Error:wrong value entered!!!" 
     1634        else: 
    15211635            if len_data < 2: len_data = 2      
    15221636            self.dx_min = float(get_pin_min.GetValue()) 
    15231637            self.dx_max = float(get_pin_max.GetValue()) 
    1524             if self.dx_min != None and self.dx_max != None:              
    1525                 if self.dx_min == self.dx_max: 
     1638            if self.dx_min < 0: 
     1639                get_pin_min.SetBackgroundColour("pink") 
     1640                msg= "Model Error:This value can not be negative!!!" 
     1641            elif self.dx_max <0: 
     1642                get_pin_max.SetBackgroundColour("pink") 
     1643                msg= "Model Error:This value can not be negative!!!" 
     1644            elif self.dx_min != None and self.dx_max != None:    
     1645                if self._is_2D(): 
     1646                    data.dqx_data[data.dqx_data==0] = self.dx_min 
     1647                    data.dqy_data[data.dqy_data==0] = self.dx_max           
     1648                elif self.dx_min == self.dx_max: 
    15261649                    data.dx[data.dx==0] = self.dx_min 
    15271650                else: 
    1528                     step = math.fabs(self.dx_max - self.dx_min)/(len_data-1)     
     1651                    step = (self.dx_max - self.dx_min)/(len_data-1)     
    15291652                    data.dx = numpy.arange(self.dx_min,self.dx_max+step/1.1,step)             
    15301653            elif self.dx_min != None:  
    1531                 data.dx[data.dx==0] = self.dx_min  
     1654                if self._is_2D(): data.dqx_data[data.dqx_data==0] = self.dx_min 
     1655                else: data.dx[data.dx==0] = self.dx_min  
    15321656            elif self.dx_max != None: 
    1533                 data.dx[data.dx==0] = self.dx_max           
     1657                if self._is_2D(): data.dqy_data[data.dqy_data==0] = self.dx_max 
     1658                else: data.dx[data.dx==0] = self.dx_max           
    15341659            self.current_smearer = smear_selection(data) 
    15351660 
     1661        if msg != None: 
     1662            wx.PostEvent(self.manager.parent, StatusEvent(status = msg )) 
    15361663        else: 
    1537             get_pin_min.SetBackgroundColour("pink") 
    1538             get_pin_max.SetBackgroundColour("pink") 
    1539             msg= "Model Error:wrong value entered!!!" 
    1540             wx.PostEvent(self.manager.parent, StatusEvent(status = msg )) 
     1664            get_pin_min.SetBackgroundColour("white") 
     1665            get_pin_max.SetBackgroundColour("white") 
    15411666        ## set smearing value whether or not the data contain the smearing info 
    15421667        self.manager.set_smearer(smearer=self.current_smearer, qmin= float(self.qmin_x),qmax= float(self.qmax_x)) 
    … …  
    15791704        # Need update param values 
    15801705        self._update_paramv_on_fit() 
     1706 
    15811707        # msg default 
    15821708        msg = None 
    … …  
    16001726        self._hide_all_smear_info()         
    16011727        ##Calculate chi2 
    1602         self.compute_chisqr(smearer= self.current_smearer)   
     1728        #self.compute_chisqr(smearer= self.current_smearer)   
    16031729        # show relevant slit sizers        
    16041730        self._show_smear_sizer() 
    … …  
    17251851            are compute when fitting 
    17261852        """ 
     1853        if event != None:  
     1854            event.Skip()     
    17271855        if self.check_invalid_panel(): 
    17281856            return 
    … …  
    17321860                            "Smear: %s"%msg)) 
    17331861            return 
     1862         
    17341863        # Need update param values 
    17351864        self._update_paramv_on_fit() 
    1736          
     1865               
    17371866        temp_smearer = None 
    17381867        self._get_smear_info() 
    … …  
    17431872            self.smear_data_left.SetValue(str(self.dq_l))    
    17441873            self.smear_data_right.SetValue(str(self.dq_r))        
    1745          
     1874 
    17461875        self._hide_all_smear_info() 
    17471876         
    … …  
    17491878        # make sure once more if it is smearer 
    17501879        self.current_smearer = smear_selection(data) 
    1751  
     1880         
    17521881        if self.enable_smearer.GetValue(): 
    1753             temp_smearer= self.current_smearer 
    17541882            if hasattr(self.data,"dxl"): 
    17551883                 
    … …  
    17621890            else: 
    17631891                wx.PostEvent(self.manager.parent, StatusEvent(status=\ 
    1764                             "Data contains smearing information %s"%msg)) 
    1765             self.smear_description_dqdata.Show(True) 
     1892                            "Data contains smearing information")) 
     1893 
     1894            #self.smear_description_dqdata.Show(True) 
    17661895            self.smear_data_left.Show(True) 
    17671896            self.smear_data_right.Show(True) 
     1897            temp_smearer= self.current_smearer 
    17681898        elif self.disable_smearer.GetValue(): 
    17691899            self.smear_description_none.Show(True) 
    17701900             
    17711901        self._show_smear_sizer() 
     1902         
    17721903        self.sizer_set_smearer.Layout() 
    17731904        self.Layout() 
    … …  
    17751906        self.manager.set_smearer(smearer=temp_smearer, qmin= float(self.qmin_x), 
    17761907                                     qmax= float(self.qmax_x))  
     1908 
    17771909        ##Calculate chi2 
    1778         self.compute_chisqr(smearer= temp_smearer)   
     1910        #self.compute_chisqr(smearer= temp_smearer) 
    17791911         
    17801912        self.state.enable_smearer=  self.enable_smearer.GetValue() 
    … …  
    17821914        self.state.pinhole_smearer = self.pinhole_smearer.GetValue() 
    17831915        self.state.slit_smearer = self.slit_smearer.GetValue() 
     1916       
     1917    def on_complete_chisqr(self, event):   
     1918        """ 
     1919            print result chisqr  
     1920            @event: activated by fitting/ complete after draw 
     1921        """ 
     1922        try: 
     1923            if event ==None: 
     1924                output= "-" 
     1925            else: 
     1926                output = event.output 
     1927            self.tcChi.SetValue(str(format_number(output))) 
     1928 
     1929            self.state.tcChi =self.tcChi 
     1930        except: 
     1931            pass   
    17841932         
    17851933    def complete_chisqr(self, output, elapsed=None):   
    … …  
    17941942 
    17951943            self.state.tcChi =self.tcChi 
    1796            
     1944 
    17971945        except: 
    17981946            pass 
    … …  
    18291977         
    18301978         
    1831     def compute_chisqr2D(self): 
     1979    def compute_chisqr2D(self,smearer=None): 
    18321980        """  
    18331981            compute chi square given a model and data 2D and set the value 
    … …  
    18431991            if self.calc_Chisqr!= None and self.calc_Chisqr.isrunning(): 
    18441992                self.calc_Chisqr.stop() 
    1845             
     1993            if smearer !=None: 
     1994                smearer.set_accuracy(accuracy = self.smear2d_accuracy) 
    18461995            self.calc_Chisqr= CalcChisqr2D( data2d= self.data, 
    18471996                                            model= self.model, 
     1997                                            smearer=smearer, 
    18481998                                            qmin= self.qmin_x, 
    18491999                                            qmax = self.qmax_x, 
    … …  
    18572007 
    18582008         
    1859     def compute_chisqr(self , smearer=None): 
     2009    def compute_chisqr(self ,output=None, smearer=None): 
    18602010        """  
    18612011            compute chi square given a model and data 1D and set the value 
    … …  
    18662016            try: 
    18672017                if hasattr(self.data,"data"): 
    1868                     self.compute_chisqr2D() 
     2018                    self.compute_chisqr2D(smearer=smearer) 
    18692019                    return 
    18702020                else: 

  • sansview/perspectives/fitting/fitting.py

    r784e2fa rf72333f  
    4444(PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent() 
    4545 
    46  
     46from fitpage import Chi2UpdateEvent 
    4747class PlotInfo: 
    4848    """ 
    … …  
    104104        #dictionary containing data name and error on dy of that data  
    105105        self.err_dy = {} 
    106          
     106        self.theory_data = None       
    107107    
    108108         
    … …  
    146146        self.fit_panel.set_model_list(self.menu_mng.get_model_list()) 
    147147        owner.Bind(fitpage.EVT_MODEL_BOX,self._on_model_panel) 
    148        
     148 
    149149        #create  menubar items 
    150150        return [(id, self.menu1, "Fitting")] 
    … …  
    370370            wx.PostEvent(self.parent, StatusEvent(status="Fitting  \ 
    371371                is cancelled" , type="stop")) 
     372            
     373    def set_smearer_nodraw(self,smearer, qmin=None, qmax=None): 
     374        """ 
     375            Get a smear object and store it to a fit problem 
     376            @param smearer: smear object to allow smearing data 
     377        """   
     378        self.current_pg=self.fit_panel.get_current_page() 
     379        self.page_finder[self.current_pg].set_smearer(smearer) 
     380        ## draw model 1D with smeared data 
     381        data =  self.page_finder[self.current_pg].get_fit_data() 
     382        model = self.page_finder[self.current_pg].get_model() 
     383        ## if user has already selected a model to plot 
     384        ## redraw the model with data smeared 
     385         
     386        smear =self.page_finder[self.current_pg].get_smearer()    
    372387             
    373388    def set_smearer(self,smearer, qmin=None, qmax=None): 
    … …  
    383398        ## if user has already selected a model to plot 
    384399        ## redraw the model with data smeared 
    385          
     400 
    386401        smear =self.page_finder[self.current_pg].get_smearer() 
    387402        if model!= None: 
    … …  
    405420              
    406421        """ 
    407         ## draw model 1D with no loaded data 
    408         self._draw_model1D( model= model, data= data,enable1D=enable1D, smearer= smearer, 
    409                            qmin= qmin, qmax= qmax, qstep= qstep ) 
    410         ## draw model 2D with no initial data 
    411         self._draw_model2D(model=model, 
    412                            data = data, 
    413                            enable2D= enable2D, 
    414                            qmin=qmin, 
    415                            qmax=qmax, 
    416                            qstep=qstep) 
     422 
     423        if data.__class__.__name__ !="Data2D":     
     424            ## draw model 1D with no loaded data 
     425            self._draw_model1D( model= model, data= data, 
     426                                                    enable1D=enable1D,  
     427                                                    smearer= smearer, 
     428                                                    qmin= qmin, qmax= qmax, qstep= qstep ) 
     429        else:      
     430            ## draw model 2D with no initial data 
     431             self._draw_model2D(model=model, 
     432                                      data = data, 
     433                                      enable2D= enable2D, 
     434                                      smearer= smearer, 
     435                                      qmin=qmin, 
     436                                      qmax=qmax, 
     437                                      qstep=qstep) 
    417438             
    418439    def onFit(self): 
    … …  
    600621            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error")) 
    601622            return 
    602      
     623 
     624         
    603625    def _onEVT_SLICER_PANEL(self, event): 
    604626        """ 
    … …  
    10871109                 
    10881110                 
    1089     def _complete1D(self, x,y, elapsed,model,data=None): 
     1111    def _complete1D(self, x,y, elapsed,index,model,data=None): 
    10901112        """ 
    10911113            Complete plotting 1D data 
    … …  
    11061128            
    11071129            title= new_plot.name 
     1130            # x, y are only in range of index  
     1131            self.theory_data = new_plot 
    11081132            #new_plot.perspective = self.get_perspective() 
    11091133            # Pass the reset flag to let the plotting event handler 
    … …  
    11161140            else: 
    11171141                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,title= str(title))) 
     1142            # Chisqr in fitpage 
     1143            current_pg=self.fit_panel.get_current_page() 
     1144            wx.PostEvent(current_pg,Chi2UpdateEvent(output=self._cal_chisqr(data=data,index=index))) 
    11181145            msg = "Plot 1D  complete !" 
    11191146            wx.PostEvent( self.parent, StatusEvent(status=msg , type="stop" )) 
    … …  
    11341161         
    11351162         
    1136     def _complete2D(self, image,data, model,  elapsed,qmin, qmax,qstep=DEFAULT_NPTS): 
     1163    def _complete2D(self, image,data, model,  elapsed,index,qmin, qmax,qstep=DEFAULT_NPTS): 
    11371164        """ 
    11381165            Complete get the result of modelthread and create model 2D 
    … …  
    11651192            theory.xmin= data.xmin 
    11661193            theory.xmax= data.xmax 
    1167        
    1168         
     1194             
     1195        self.theory_data = theory 
    11691196        ## plot 
    11701197        wx.PostEvent(self.parent, NewPlotEvent(plot=theory, 
    11711198                         title="Analytical model 2D ", reset=True )) 
     1199        # Chisqr in fitpage 
     1200        current_pg=self.fit_panel.get_current_page() 
     1201        wx.PostEvent(current_pg,Chi2UpdateEvent(output=self._cal_chisqr(data=data,index=index))) 
    11721202        msg = "Plot 2D complete !" 
    11731203        wx.PostEvent( self.parent, StatusEvent( status= msg , type="stop" )) 
    1174           
     1204      
    11751205    def _on_data_error(self, event): 
    11761206        """ 
    … …  
    11791209        """ 
    11801210        self.err_dy = event.err_dy 
    1181         #print "receiving error dy",self.err_dy 
    11821211          
    1183     def _draw_model2D(self,model,data=None,description=None, enable2D=False, 
     1212    def _draw_model2D(self,model,data=None, smearer= None,description=None, enable2D=False, 
    11841213                      qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS): 
    11851214        """ 
    … …  
    12081237                x= data.x_bins 
    12091238                y= data.y_bins 
    1210                  
     1239                
    12111240        if not enable2D: 
    1212             return 
     1241            return None,None 
    12131242        try: 
    12141243            from model_thread import Calc2D 
    … …  
    12161245            if self.calc_2D != None and self.calc_2D.isrunning(): 
    12171246                self.calc_2D.stop() 
     1247 
    12181248            self.calc_2D = Calc2D(  x= x, 
    12191249                                    y= y, 
    12201250                                    model= model,  
    12211251                                    data = data, 
     1252                                    smearer = smearer, 
    12221253                                    qmin= qmin, 
    12231254                                    qmax= qmax, 
    … …  
    12261257                                    updatefn= self._update2D ) 
    12271258            self.calc_2D.queue() 
    1228              
     1259 
    12291260        except: 
    12301261            msg= " Error occurred when drawing %s Model 2D: "%model.name 
    12311262            msg+= " %s"%sys.exc_value 
    12321263            wx.PostEvent( self.parent, StatusEvent(status= msg )) 
    1233             return   
     1264 
    12341265    
    12351266    def _draw_model1D(self, model, data=None, smearer= None, 
    … …  
    12571288         
    12581289        if not enable1D: 
    1259             return 
     1290            return  
    12601291     
    12611292        try: 
    … …  
    12731304                                  updatefn = self._update1D  ) 
    12741305            self.calc_1D.queue() 
    1275              
     1306 
    12761307        except: 
    12771308            msg= " Error occurred when drawing %s Model 1D: "%model.name 
    12781309            msg+= " %s"%sys.exc_value 
    12791310            wx.PostEvent( self.parent, StatusEvent(status= msg )) 
    1280             return   
    1281              
    1282  
     1311 
     1312    def _cal_chisqr(self, data=None, index=None):  
     1313        """ 
     1314            Get handy Chisqr using the output from draw1D and 2D,  
     1315            instead of calling expansive CalcChisqr in guithread 
     1316        """ 
     1317        # default chisqr 
     1318        chisqr = None 
     1319        # return None if data == None 
     1320        if data == None: return chisqr 
     1321 
     1322        # Get data: data I, theory I, and data dI in order 
     1323        if data.__class__.__name__ =="Data2D": 
     1324            if index == None: index = numpy.ones(len(data.data),ntype=bool) 
     1325            fn = data.data[index]  
     1326            gn = self.theory_data.data[index] 
     1327            en = data.err_data[index] 
     1328        else: 
     1329            # 1 d theory from model_thread is only in the range of index 
     1330            if index == None: index = numpy.ones(len(data.y),ntype=bool) 
     1331             
     1332            fn = data.y[index]  
     1333            gn = self.theory_data.y 
     1334            en = data.dy[index] 
     1335 
     1336        # residual 
     1337        res = (fn - gn)/en 
     1338        # get chisqr only w/finite 
     1339        chisqr = numpy.average(res[numpy.isfinite(res)]*res[numpy.isfinite(res)]) 
     1340 
     1341        return chisqr 
     1342     
     1343     
    12831344def profile(fn, *args, **kw): 
    12841345    import cProfile, pstats, os 

  • sansview/perspectives/fitting/gui_thread.py

    r425ef040 rf72333f  
    1010from data_util.calcthread import CalcThread 
    1111from sans.fit.AbstractFitEngine import FitData2D, FitData1D, SansAssembly 
    12  
     12from DataLoader.smearing_2d import Smearer2D 
    1313 
    1414class CalcChisqr1D(CalcThread): 
    … …  
    8787     
    8888    def __init__(self,data2d, model, 
     89                 smearer, 
    8990                 qmin, 
    9091                 qmax, 
    … …  
    105106            msg= str(data2d.__class__.__name__) 
    106107            raise ValueError, "need Data2D to compute chisqr. Current class %s"%msg 
    107         
     108        self.smearer = smearer 
    108109        self.fitdata = FitData2D(sans_data2d=data2d ,data=data2d.data, err_data=data2d.err_data) 
    109110        self.fitdata.setFitRange(qmin=qmin,qmax=qmax) 
    110111      
    111112        self.model = model 
    112        
     113 
    113114        self.starttime = 0   
    114115         
    … …  
    128129        """ 
    129130        self.starttime = time.time() 
    130         
     131         
    131132        output= None 
    132133        res=[] 
    133134        try: 
    134             res = self.fitdata.residuals(self.model.evalDistribution) 
     135            if self.smearer == None: 
     136                fn = self.model.evalDistribution 
     137            else: 
     138                # Set model in smearer 
     139                self.smearer.set_model(self.model) 
     140                # set fn 
     141                fn = self.smearer 
     142                # set self.smearer != None in fitdata 
     143                self.fitdata.set_smearer(fn) 
     144 
     145            res = self.fitdata.residuals(fn) 
    135146            sum=0 
    136147            for item in res: 

  • sansview/perspectives/fitting/model_thread.py

    r51a71a3 rf72333f  
    33import sys 
    44import numpy,math 
    5  
     5from DataLoader.smearing_2d import Smearer2D 
     6import fitpage 
    67class Calc2D(CalcThread): 
    78    """ 
    … …  
    1213    """ 
    1314     
    14     def __init__(self, x, y, data,model,qmin, qmax,qstep, 
     15    def __init__(self, x, y, data,model,smearer,qmin, qmax,qstep, 
    1516                 completefn = None, 
    1617                 updatefn   = None, 
    … …  
    3132        # the model on to calculate 
    3233        self.model = model 
     34        self.smearer = smearer#(data=self.data,model=self.model) 
    3335        self.starttime = 0   
    3436         
    … …  
    5153            self.qx_data = self.data.qx_data 
    5254            self.qy_data = self.data.qy_data 
     55            self.dqx_data = self.data.dqx_data 
     56            self.dqy_data = self.data.dqy_data 
    5357            self.mask    = self.data.mask 
    5458        else:           
    … …  
    8690            # Only qmin value will be consider for the detector 
    8791            index_model = index_data   
    88               
    89         value = self.model.evalDistribution([self.qx_data[index_model],self.qy_data[index_model]] ) 
     92 
     93        if self.smearer != None: 
     94            # Set smearer w/ data, model and index. 
     95            fn = self.smearer 
     96            fn.set_model(self.model) 
     97            fn.set_index(index_model) 
     98            # Get necessary data from self.data and set the data for smearing 
     99            fn.get_data() 
     100            # Calculate smeared Intensity (by Gaussian averaging): DataLoader/smearing2d/Smearer2D() 
     101            value = fn.get_value() 
     102 
     103        else:     
     104            # calculation w/o smearing 
     105            value =  self.model.evalDistribution([self.qx_data[index_model],self.qy_data[index_model]]) 
    90106 
    91107        output = numpy.zeros(len(self.qx_data)) 
    92108         
    93109        # output default is None 
    94         # This method is to distinguish between masked point and data point = 0. 
     110        # This method is to distinguish between masked point(nan) and data point = 0. 
    95111        output = output/output 
    96112        # set value for self.mask==True, else still None to Plottools 
    97113        output[index_model] = value  
     114 
    98115        elapsed = time.time()-self.starttime 
    99116        self.complete( image = output, 
    … …  
    101118                       model = self.model, 
    102119                       elapsed = elapsed, 
     120                       index = index_model, 
    103121                       qmin = self.qmin, 
    104122                       qmax = self.qmax, 
    105123                       qstep = self.qstep ) 
    106124         
    107     
    108      
    109125 
    110126class Calc1D(CalcThread): 
    … …  
    153169        
    154170        self.complete(x= self.x[index], y= output[index],  
    155                       elapsed=elapsed, model= self.model, data=self.data) 
    156          
    157   
     171                      elapsed=elapsed,index=index, model= self.model, data=self.data) 
     172 
     173         
     174    def results(self): 
     175        """ 
     176            Send resuts of the computation 
     177        """ 
     178        return [self.out, self.index] 
    158179                 
    159180class CalcCommandline: 
Note: See TracChangeset for help on using the changeset viewer.