Changeset a0da535 in sasview for sansview/perspectives


Ignore:
Timestamp:
Jan 19, 2011 4:10:35 PM (14 years ago)
Author:
Gervaise Alina <gervyh@…>
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:
c91c29e
Parents:
1d78e4b
Message:

add load many data fitting

File:
1 edited

Legend:

Unmodified
Added
Removed
  • sansview/perspectives/fitting/fitting.py

    r3658abed ra0da535  
    1212 
    1313 
    14 import  re 
     14import re 
    1515import sys 
    1616import wx 
     
    2727 
    2828from DataLoader.loader import Loader 
    29  
    3029from sans.guiframe.dataFitting import Data2D 
    3130from sans.guiframe.dataFitting import Data1D 
    3231from sans.guiframe.dataFitting import Theory1D 
    33  
    34 from sans.guicomm.events import NewPlotEvent, StatusEvent   
    35 from sans.guicomm.events import EVT_SLICER_PANEL,ERR_DATA,EVT_REMOVE_DATA 
    36 from sans.guicomm.events import EVT_SLICER_PARS_UPDATE 
    37 from sans.guicomm.events import EVT_FITSTATE_UPDATE 
     32from sans.guiframe.events import NewPlotEvent, StatusEvent   
     33from sans.guiframe.events import EVT_SLICER_PANEL 
     34from sans.guiframe.events import EVT_REMOVE_DATA 
     35from sans.guiframe.events import ERR_DATA 
     36from sans.guiframe.events import EVT_SLICER_PARS_UPDATE 
     37from sans.guiframe.events import EVT_FITSTATE_UPDATE 
    3838 
    3939from sans.fit.AbstractFitEngine import Model 
    4040from sans.fit.AbstractFitEngine import FitAbort 
    41 from console import ConsoleUpdate 
    42  
    43 from fitproblem import FitProblem 
    44 from fitpanel import FitPanel 
    45 from fit_thread import FitThread 
    46 from pagestate import Reader 
     41from .console import ConsoleUpdate 
     42from .fitproblem import FitProblem 
     43from .fitpanel import FitPanel 
     44from .fit_thread import FitThread 
     45from .pagestate import Reader 
     46from .fitpage import Chi2UpdateEvent 
    4747 
    4848DEFAULT_BEAM = 0.005 
     
    5252 
    5353(PageInfoEvent, EVT_PAGE_INFO)   = wx.lib.newevent.NewEvent() 
    54 #(FitStateUpdateEvent, EVT_STATE_UPDATE)   = wx.lib.newevent.NewEvent() 
    55 from fitpage import Chi2UpdateEvent 
    5654 
    5755 
     
    169167        """ 
    170168        Plugin.on_perspective(self,event=event) 
    171         if self.sim_page !=None: 
     169        if self.sim_page != None: 
    172170            msg= "Simultaneous Fit page already opened" 
    173171            wx.PostEvent(self.parent, StatusEvent(status= msg)) 
     
    180178        Show a general help dialog.  
    181179        """ 
    182          
    183180        from help_panel import  HelpWindow 
    184181        frame = HelpWindow(None, -1, 'HelpWindow')     
     
    213210            else: 
    214211                if item.name == graph.selected_plottable : 
    215                     if item.name in ["$I_{obs}(q)$","$I_{fit}(q)$","$P_{fit}(r)$"]: 
     212                    if item.name in ["$I_{obs}(q)$","$I_{fit}(q)$", 
     213                                     "$P_{fit}(r)$"]: 
    216214                        return []  
    217215                    if hasattr(item, "group_id"): 
     
    271269        """ 
    272270        return True 
    273    
     271     
     272    def set_data(self, data_list): 
     273        """ 
     274        receive a list of data to fit 
     275        """ 
     276        for data in data_list: 
     277            self.add_fit_page(data=data) 
     278            wx.PostEvent(self.parent, NewPlotEvent(plot=data,  
     279                                                   title=str(data.title))) 
     280             
     281             
    274282    def set_state(self, state=None, datainfo=None, format=None): 
    275283        """ 
     
    607615            new_plot.group_id = data.group_id 
    608616            new_plot.id = data.id + name 
    609             wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=data.name)) 
     617            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
     618                                                   title=data.name)) 
    610619        if theory: 
    611620            new_plot_data = Data1D(x=[], y=[], dx=None, dy=None) 
     
    700709            else: 
    701710                msg = "Page was already Created" 
    702                 wx.PostEvent(self.parent, StatusEvent(status=msg, info="warning")) 
     711                wx.PostEvent(self.parent, StatusEvent(status=msg, 
     712                                                       info="warning")) 
    703713        except: 
    704714            msg = "Creating Fit page: %s"%sys.exc_value 
     
    728738        
    729739        if hasattr(event.data,"is_data"): 
    730             if not event.data.is_data or event.data.__class__.__name__=="Data1D": 
     740            if not event.data.is_data or \ 
     741                event.data.__class__.__name__=="Data1D": 
    731742                self.fit_panel.close_page_with_data(event.data)  
    732743         
     
    913924 
    914925                    # Display result on each page  
    915                     page.onsetValues(result.fitness, small_param_name,small_out,small_cov) 
     926                    page.onsetValues(result.fitness, 
     927                                      small_param_name, 
     928                                      small_out,small_cov) 
    916929        except: 
    917930             msg= "Simultaneous Fit completed" 
     
    9981011            self.menu1.FindItemByPosition(0).Check(True) 
    9991012            self.menu1.FindItemByPosition(1).Check(False) 
    1000              
    10011013        ## post a message to status bar 
    1002         wx.PostEvent(self.parent, StatusEvent(status="Engine set to: %s" % self._fit_engine)) 
    1003     
    1004         ## Bind every open fit page with a newevent to know the current fitting engine 
    1005         import fitpage 
    1006         event= fitpage.FitterTypeEvent() 
     1014        msg = "Engine set to: %s" % self._fit_engine 
     1015        wx.PostEvent(self.parent,  
     1016                     StatusEvent(status=msg)) 
     1017        ## Bind every open fit page with a newevent to  
     1018        #know the current fitting engine 
     1019        #import fitpage 
     1020        event = fitpage.FitterTypeEvent() 
    10071021        event.type = self._fit_engine 
    10081022        for key in self.page_finder.keys(): 
     
    10331047        ## example trying to call set_panel on self.sim_page 
    10341048        if self.current_pg != self.sim_page : 
    1035             if self.page_finder[self.current_pg].get_model()== None: 
    1036                  
    1037                 model.name = "M"+str(self.index_model) 
     1049            if self.page_finder[self.current_pg].get_model() is None: 
     1050                model.name = "M" + str(self.index_model) 
    10381051                self.index_model += 1   
    10391052            else: 
    10401053                model.name= self.page_finder[self.current_pg].get_model().name 
    1041              
    10421054            data = self.page_finder[self.current_pg].get_fit_data() 
    1043              
    10441055            # save the name containing the data name with the appropriate model 
    10451056            self.page_finder[self.current_pg].set_model(model) 
     
    10471058            self.page_finder[self.current_pg].set_range(qmin=qmin, qmax=qmax) 
    10481059            
    1049             if self.sim_page!=None: 
     1060            if self.sim_page != None: 
    10501061                self.sim_page.draw_page() 
    10511062         
     
    10621073        # will be plotted automatically. If a page already exists, 
    10631074        # the content will be updated and the plot refreshed 
    1064         self.fit_panel.add_model_page(model,topmenu=True) 
     1075        self.fit_panel.add_model_page(model, topmenu=True) 
    10651076 
    10661077    def _update1D(self,x, output): 
     
    10681079        Update the output of plotting model 1D 
    10691080        """ 
    1070         wx.PostEvent(self.parent, StatusEvent(status="Plot \ 
    1071         #updating ... ",type="update")) 
     1081        msg = "Plot updating ... " 
     1082        wx.PostEvent(self.parent, StatusEvent(status=msg,type="update")) 
    10721083        self.ready_fit() 
    10731084        #self.calc_thread.ready(0.01) 
     
    11011112        center_y      = theory.detector[0].beam_center.y/pixel_width_y 
    11021113 
    1103         # theory default: assume the beam center is located at the center of sqr detector 
     1114        # theory default: assume the beam  
     1115        #center is located at the center of sqr detector 
    11041116        xmax = qmax 
    11051117        xmin = -qmax 
     
    11081120         
    11091121        x=  numpy.linspace(start= -1*qmax, 
     1122                               stop=qmax, 
     1123                               num=qstep, 
     1124                               endpoint=True)   
     1125        y = numpy.linspace(start=-1*qmax, 
    11101126                               stop= qmax, 
    11111127                               num= qstep, 
    1112                                endpoint=True )   
    1113         y = numpy.linspace(start= -1*qmax, 
    1114                                stop= qmax, 
    1115                                num= qstep, 
    1116                                endpoint=True ) 
     1128                               endpoint=True) 
    11171129          
    11181130        ## use data info instead 
     
    11291141        mask    = numpy.ones(len(qx_data), dtype = bool) 
    11301142         
    1131         # calculate the range of qx and qy: this way, it is a little more independent 
     1143        # calculate the range of qx and qy: this way, 
     1144        # it is a little more independent 
    11321145        x_size = xmax- xmin 
    11331146        y_size = ymax -ymin 
     
    11501163         
    11511164        # max and min taking account of the bin sizes 
    1152         theory.xmin= xmin  
    1153         theory.xmax= xmax 
    1154         theory.ymin= ymin  
    1155         theory.ymax= ymax  
     1165        theory.xmin = xmin  
     1166        theory.xmax = xmax 
     1167        theory.ymin = ymin  
     1168        theory.ymax = ymax  
    11561169        theory.group_id = "Model" 
    11571170        theory.id = "Model" 
     
    11901203            new_plot.group_id = my_info.group_id 
    11911204             
    1192             new_plot.xaxis( my_info._xaxis,  my_info._xunit) 
    1193             new_plot.yaxis( my_info._yaxis, my_info._yunit) 
    1194             if data!=None: 
     1205            new_plot.xaxis(my_info._xaxis,  my_info._xunit) 
     1206            new_plot.yaxis(my_info._yaxis, my_info._yunit) 
     1207            if data != None: 
    11951208                if new_plot.id == data.id: 
    11961209                    new_plot.id += "Model" 
    11971210                new_plot.is_data =False  
    11981211            
    1199             title= new_plot.name 
     1212            title = new_plot.name 
    12001213            # x, y are only in range of index  
    12011214            self.theory_data = new_plot 
     
    12031216            # Pass the reset flag to let the plotting event handler 
    12041217            # know that we are replacing the whole plot 
    1205             if title== None: 
     1218            if title is None: 
    12061219                title = "Analytical model 1D " 
    1207             if data ==None: 
     1220            if data is None: 
    12081221                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    12091222                             title=str(title), reset=True)) 
    12101223            else: 
    1211                 wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot,title= str(title))) 
     1224                wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
     1225                                                       title= str(title))) 
    12121226            # Chisqr in fitpage 
    1213             current_pg=self.fit_panel.get_current_page() 
    1214             wx.PostEvent(current_pg,Chi2UpdateEvent(output=self._cal_chisqr(data=data,index=index))) 
     1227            current_pg = self.fit_panel.get_current_page() 
     1228            wx.PostEvent(current_pg, 
     1229                         Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
     1230                                                                 index=index))) 
    12151231            msg = "Plot 1D  complete !" 
    1216             wx.PostEvent( self.parent, StatusEvent(status=msg , type="stop" )) 
     1232            wx.PostEvent( self.parent, StatusEvent(status=msg, type="stop" )) 
    12171233        except: 
    1218             msg= " Error occurred when drawing %s Model 1D: "%new_plot.name 
    1219             msg+= " %s"%sys.exc_value 
    1220             wx.PostEvent( self.parent, StatusEvent(status= msg, type="stop")) 
     1234            msg = " Error occurred when drawing %s Model 1D: " % new_plot.name 
     1235            msg += " %s"  % sys.exc_value 
     1236            wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    12211237    
    12221238    def _update2D(self, output,time=None): 
     
    12251241        """ 
    12261242        wx.PostEvent(self.parent, StatusEvent(status="Plot \ 
    1227         #updating ... ",type="update")) 
     1243        #updating ... ", type="update")) 
    12281244        self.ready_fit() 
    12291245        #self.calc_thread.ready(0.01) 
     
    12371253        err_image = numpy.zeros(numpy.shape(image)) 
    12381254        
    1239         theory= Data2D(image= image , err_image= err_image) 
    1240         theory.name= model.name 
    1241          
    1242         if data ==None: 
    1243             self._fill_default_model2D(theory=theory, qmax=qmax, qstep=qstep, 
     1255        theory= Data2D(image=image, err_image=err_image) 
     1256        theory.name = model.name 
     1257         
     1258        if data is None: 
     1259            self._fill_default_model2D(theory=theory,  
     1260                                       qmax=qmax,  
     1261                                       qstep=qstep, 
    12441262                                        qmin= qmin) 
    12451263         
    12461264        else: 
    1247             theory.id= data.id+"Model" 
    1248             theory.group_id= data.name+"Model" 
    1249             theory.x_bins= data.x_bins 
    1250             theory.y_bins= data.y_bins 
    1251             theory.detector= data.detector 
    1252             theory.source= data.source 
     1265            theory.id = data.id + "Model" 
     1266            theory.group_id = data.name + "Model" 
     1267            theory.x_bins = data.x_bins 
     1268            theory.y_bins = data.y_bins 
     1269            theory.detector = data.detector 
     1270            theory.source = data.source 
    12531271            theory.is_data = False  
    12541272            theory.qx_data = data.qx_data 
    12551273            theory.qy_data = data.qy_data 
    12561274            theory.q_data = data.q_data 
    1257             theory.err_data = err_image#numpy.zeros(len(data.err_data))#data.err_data 
     1275            #numpy.zeros(len(data.err_data))#data.err_data 
     1276            theory.err_data = err_image 
    12581277            theory.mask = data.mask 
    12591278            ## plot boundaries 
    1260             theory.ymin= data.ymin 
    1261             theory.ymax= data.ymax 
    1262             theory.xmin= data.xmin 
    1263             theory.xmax= data.xmax 
    1264              
     1279            theory.ymin = data.ymin 
     1280            theory.ymax = data.ymax 
     1281            theory.xmin = data.xmin 
     1282            theory.xmax = data.xmax 
    12651283        self.theory_data = theory 
    12661284        ## plot 
    12671285        wx.PostEvent(self.parent, NewPlotEvent(plot=theory, 
    1268                          title="Analytical model 2D ", reset=True )) 
     1286                         title="Analytical model 2D ", reset=True)) 
    12691287        # Chisqr in fitpage 
    12701288        current_pg = self.fit_panel.get_current_page() 
    12711289        wx.PostEvent(current_pg, 
    1272             Chi2UpdateEvent(output=self._cal_chisqr(data=data,index=index))) 
     1290            Chi2UpdateEvent(output=self._cal_chisqr(data=data, index=index))) 
    12731291        msg = "Plot 2D complete !" 
    1274         wx.PostEvent( self.parent, StatusEvent(status=msg, type="stop" )) 
     1292        wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    12751293      
    12761294    def _on_data_error(self, event): 
     
    12811299        self.err_dy = event.err_dy 
    12821300          
    1283     def _draw_model2D(self,model,data=None, smearer= None,description=None, enable2D=False, 
    1284                       qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS): 
     1301    def _draw_model2D(self, model, data=None, smearer=None, 
     1302                      description=None, enable2D=False, 
     1303                      qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, 
     1304                       qstep=DEFAULT_NPTS): 
    12851305        """ 
    12861306        draw model in 2D 
     
    12941314             
    12951315        """ 
    1296         x=  numpy.linspace(start= -1*qmax, 
    1297                                stop= qmax, 
    1298                                num= qstep, 
    1299                                endpoint=True  
     1316        x=  numpy.linspace(start=-1*qmax, 
     1317                               stop=qmax, 
     1318                               num=qstep, 
     1319                               endpoint=True 
    13001320        y = numpy.linspace(start= -1*qmax, 
    1301                                stop= qmax, 
    1302                                num= qstep, 
    1303                                endpoint=True ) 
     1321                               stop=qmax, 
     1322                               num=qstep, 
     1323                               endpoint=True) 
    13041324        ## use data info instead 
    1305         if data !=None: 
     1325        if data is not None: 
    13061326            ## check if data2D to plot 
    13071327            if hasattr(data, "x_bins"): 
    13081328                enable2D = True 
    1309                 x= data.x_bins 
    1310                 y= data.y_bins 
     1329                x = data.x_bins 
     1330                y = data.y_bins 
    13111331                
    13121332        if not enable2D: 
    1313             return None,None 
     1333            return None, None 
    13141334        try: 
    13151335            from model_thread import Calc2D 
    13161336            ## If a thread is already started, stop it 
    1317             if self.calc_2D != None and self.calc_2D.isrunning(): 
     1337            if (self.calc_2D is not None) and self.calc_2D.isrunning(): 
    13181338                self.calc_2D.stop() 
    13191339 
    1320             self.calc_2D = Calc2D(  x= x, 
    1321                                     y= y, 
    1322                                     model= model,  
    1323                                     data = data, 
    1324                                     smearer = smearer, 
    1325                                     qmin= qmin, 
    1326                                     qmax= qmax, 
    1327                                     qstep= qstep, 
    1328                                     completefn= self._complete2D, 
    1329                                     updatefn= self._update2D ) 
     1340            self.calc_2D = Calc2D(x=x, 
     1341                                    y=y, 
     1342                                    model=model,  
     1343                                    data=data, 
     1344                                    smearer=smearer, 
     1345                                    qmin=qmin, 
     1346                                    qmax=qmax, 
     1347                                    qstep=qstep, 
     1348                                    completefn=self._complete2D, 
     1349                                    updatefn=self._update2D) 
    13301350            self.calc_2D.queue() 
    13311351 
    13321352        except: 
    1333             msg= " Error occurred when drawing %s Model 2D: " % model.name 
    1334             msg+= " %s" % sys.exc_value 
     1353            msg = " Error occurred when drawing %s Model 2D: " % model.name 
     1354            msg += " %s" % sys.exc_value 
    13351355            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    13361356 
     
    13451365         
    13461366        """ 
    1347         x=  numpy.linspace(start= qmin, 
    1348                            stop= qmax, 
    1349                            num= qstep, 
     1367        x=  numpy.linspace(start=qmin, 
     1368                           stop=qmax, 
     1369                           num=qstep, 
    13501370                           endpoint=True 
    13511371                           ) 
    1352         if data!=None: 
     1372        if data is not None: 
    13531373            ## check for data2D 
    13541374            if hasattr(data,"x_bins"): 
     
    13591379            if qmax == DEFAULT_QMAX: 
    13601380                qmax = max(data.x)  
    1361             
    1362          
    13631381        if not enable1D: 
    13641382            return  
    1365      
    13661383        try: 
    13671384            from model_thread import Calc1D 
    13681385            ## If a thread is already started, stop it 
    1369             if self.calc_1D!= None and self.calc_1D.isrunning(): 
     1386            if (self.calc_1D is not None) and self.calc_1D.isrunning(): 
    13701387                self.calc_1D.stop() 
    1371             self.calc_1D= Calc1D( x= x, 
    1372                                   data = data, 
    1373                                   model= model,  
    1374                                   qmin = qmin, 
    1375                                   qmax = qmax, 
    1376                                   smearer = smearer, 
    1377                                   completefn = self._complete1D, 
    1378                                   updatefn = self._update1D  ) 
     1388            self.calc_1D = Calc1D(x=x, 
     1389                                  data=data, 
     1390                                  model=model,  
     1391                                  qmin=qmin, 
     1392                                  qmax=qmax, 
     1393                                  smearer=smearer, 
     1394                                  completefn=self._complete1D, 
     1395                                  updatefn=self._update1D) 
    13791396            self.calc_1D.queue() 
    13801397 
    13811398        except: 
    1382             msg= " Error occurred when drawing %s Model 1D: "%model.name 
    1383             msg+= " %s"%sys.exc_value 
    1384             wx.PostEvent( self.parent, StatusEvent(status= msg )) 
     1399            msg = " Error occurred when drawing %s Model 1D: " % model.name 
     1400            msg += " %s" % sys.exc_value 
     1401            wx.PostEvent(self.parent, StatusEvent(status=msg)) 
    13851402 
    13861403    def _cal_chisqr(self, data=None, index=None):  
     
    13971414        # Get data: data I, theory I, and data dI in order 
    13981415        if data.__class__.__name__ =="Data2D": 
    1399             if index == None: index = numpy.ones(len(data.data),ntype=bool) 
    1400             index = index & (data.err_data !=0 )   # get rid of zero error points 
     1416            if index == None:  
     1417                index = numpy.ones(len(data.data),ntype=bool) 
     1418            # get rid of zero error points 
     1419            index = index & (data.err_data != 0)   
    14011420            fn = data.data[index]  
    14021421            gn = self.theory_data.data[index] 
     
    14041423        else: 
    14051424            # 1 d theory from model_thread is only in the range of index 
    1406             if index == None: index = numpy.ones(len(data.y),ntype=bool) 
    1407             if data.dy== None or data.dy ==[]: 
     1425            if index == None: 
     1426                index = numpy.ones(len(data.y), ntype=bool) 
     1427            if data.dy == None or data.dy == []: 
    14081428                dy = numpy.ones(len(data.y)) 
    14091429            else: 
    1410                 ## Set consitently w/AbstractFitengine: But this should be corrected later. 
     1430                ## Set consitently w/AbstractFitengine: 
     1431                # But this should be corrected later. 
    14111432                dy = data.dy 
    14121433                dy[dy==0] = 1   
     
    14141435            gn = self.theory_data.y 
    14151436            en = dy[index] 
    1416  
    14171437        # residual 
    14181438        res = (fn - gn)/en 
    14191439        # get chisqr only w/finite 
    1420         chisqr = numpy.average(res[numpy.isfinite(res)]*res[numpy.isfinite(res)]) 
    1421  
     1440        val = res[numpy.isfinite(res)]*res[numpy.isfinite(res)] 
     1441        chisqr = numpy.average(val) 
    14221442        return chisqr 
    14231443     
Note: See TracChangeset for help on using the changeset viewer.