Changeset 2296316 in sasview for sansview/perspectives/fitting


Ignore:
Timestamp:
Mar 29, 2011 12:40:33 PM (14 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:
e0e2c44f
Parents:
29ef718
Message:

moving features from the branch

Location:
sansview/perspectives/fitting
Files:
2 added
9 edited

Legend:

Unmodified
Added
Removed

  • sansview/perspectives/fitting/basepage.py

    r9466f2d6 r2296316  
    158158        #self.onSave(event=None) 
    159159        self.Bind(wx.EVT_CONTEXT_MENU, self.onContextMenu) 
     160         
     161        # bind key event 
     162        self.Bind(wx.EVT_LEFT_DOWN, self.on_left_down) 
    160163 
    161164        ## create the basic structure of the panel with empty sizer 
    … …  
    427430                                            style=wx.RB_GROUP) 
    428431        self.enable_disp = wx.RadioButton(self, -1, 'On', (10, 30)) 
    429         
     432 
     433        self.disp_help_bt = wx.Button(self,wx.NewId(),'?', size=(20,15)) 
     434        self.disp_help_bt.Bind(wx.EVT_BUTTON,  
     435                        self.on_pd_help_clicked,id= self.disp_help_bt.GetId()) 
     436        self.disp_help_bt.SetToolTipString("Helps for Polydispersion.")        
    430437         
    431438        self.Bind(wx.EVT_RADIOBUTTON, self._set_dipers_Param, 
    … …  
    442449        sizer_dispersion.Add((20,20)) 
    443450        sizer_dispersion.Add(self.disable_disp ) 
    444         sizer_dispersion.Add((10,10)) 
    445          
    446         ## fill a sizer with the combobox to select dispersion type 
    447         sizer_select_dispers = wx.BoxSizer(wx.HORIZONTAL)   
    448         self.model_disp = wx.StaticText(self, -1, 'Distribution Function ') 
    449              
    450         import sans.models.dispersion_models  
    451         self.polydisp= sans.models.dispersion_models.models 
    452         self.disp_box = wx.ComboBox(self, -1) 
    453  
    454         for key, value in self.polydisp.iteritems(): 
    455             name = str(key) 
    456             self.disp_box.Append(name,value) 
    457         self.disp_box.SetStringSelection("gaussian")  
    458         wx.EVT_COMBOBOX(self.disp_box,-1, self._on_select_Disp)  
    459               
    460         sizer_select_dispers.Add((10,10))  
    461         sizer_select_dispers.Add(self.model_disp)  
    462         sizer_select_dispers.Add(self.disp_box,0, 
    463                 wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,border=5) 
    464        
    465         self.model_disp.Hide() 
    466         self.disp_box.Hide() 
    467          
     451        sizer_dispersion.Add((25,20)) 
     452        sizer_dispersion.Add(self.disp_help_bt) 
     453         
     454        ## fill a sizer for dispersion          
    468455        boxsizer1.Add( sizer_dispersion,0, 
    469456                wx.TOP|wx.BOTTOM|wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,border=5) 
    470457        #boxsizer1.Add( (10,10) ) 
    471         boxsizer1.Add( sizer_select_dispers ) 
    472         self.sizer4_4 = wx.GridBagSizer(5,5) 
     458        #boxsizer1.Add( sizer_select_dispers ) 
     459        self.sizer4_4 = wx.GridBagSizer(6,5) 
     460 
    473461        boxsizer1.Add( self.sizer4_4  ) 
    474462        #----------------------------------------------------- 
    … …  
    484472        self.SetupScrolling() 
    485473 
    486     def select_disp_angle(self, event):  
    487         """ 
    488         Event for when a user select a parameter to average over. 
    489          
    490         :param event: radiobutton event 
    491          
    492         """ 
    493         self.values=[] 
    494         self.weights=[] 
    495         if event.GetEventObject()==self.noDisper_rbox: 
    496             if self.noDisper_rbox.GetValue(): 
    497                 #No array dispersity apply yet 
    498                 self._reset_dispersity() 
    499                 ## Redraw the model ??? 
    500                 self._draw_model() 
    501         # Go through the list of dispersion check boxes to identify 
    502         # which one has changed  
    503         for p in self.disp_cb_dict: 
    504             self.state.disp_cb_dict[p]=  self.disp_cb_dict[p].GetValue() 
    505             # Catch which one of the box was just checked or unchecked. 
    506             if event.GetEventObject() == self.disp_cb_dict[p]:               
    507                 if self.disp_cb_dict[p].GetValue() == True: 
    508                      
    509                     ##Temp. FIX for V1.0 regarding changing checkbox  
    510                     #to radiobutton. 
    511                     ##This (self._reset_dispersity) should be removed  
    512                     #when the array dispersion is fixed.                 
    513                     self._reset_dispersity() 
    514  
    515                     # The user wants this parameter to be averaged.  
    516                     # Pop up the file selection dialog. 
    517                     path = self._selectDlg() 
    518                      
    519                     # If nothing was selected, just return 
    520                     if path is None: 
    521                         self.disp_cb_dict[p].SetValue(False) 
    522                         self.noDisper_rbox.SetValue(True) 
    523                         return 
    524                     try: 
    525                         self._default_save_location = os.path.dirname(path) 
    526                     except: 
    527                         pass  
    528                     try: 
    529                         self.values,self.weights = self.read_file(path) 
    530                     except: 
    531                         msg="Could not read input file" 
    532                         wx.PostEvent(self.parent.parent,  
    533                                      StatusEvent(status=msg)) 
    534                         return 
    535                      
    536                     # If any of the two arrays is empty, notify the user that we won't 
    537                     # proceed  
    538                     if self.values is None or self.weights is None or \ 
    539                          self.values ==[] or self.weights ==[]: 
    540                         msg = "The loaded %s distrubtion is" 
    541                         msg + " corrupted or empty" % p 
    542                         wx.PostEvent(self.parent.parent,  
    543                                      StatusEvent(status=msg)) 
    544                         return 
    545                          
    546                     # Tell the user that we are about to apply the distribution 
    547                     msg = "Applying loaded %s distribution: %s" % (p, path) 
    548                     wx.PostEvent(self.parent.parent, StatusEvent(status=msg))   
    549                      
    550                     # Create the dispersion objects 
    551                     from sans.models.dispersion_models import ArrayDispersion 
    552                     disp_model = ArrayDispersion() 
    553                     disp_model.set_weights(self.values, self.weights) 
    554                     
    555                     # Store the object to make it persist outside the 
    556                     # scope of this method 
    557                     #TODO: refactor model to clean this up? 
    558                     self._disp_obj_dict[p] = disp_model 
    559                     self.state._disp_obj_dict [p]= disp_model 
    560                     self.state.values = [] 
    561                     self.state.weights = [] 
    562                     self.state.values = copy.deepcopy(self.values) 
    563                     self.state.weights = copy.deepcopy(self.weights) 
    564                     # Set the new model as the dispersion object for the  
    565                     #selected parameter 
    566                     self.model.set_dispersion(p, disp_model) 
    567                     # Store a reference to the weights in the model object  
    568                     #so that 
    569                     # it's not lost when we use the model within another thread. 
    570                     #TODO: total hack - fix this 
    571                     self.state.model= self.model.clone() 
    572  
    573                     self.model._persistency_dict = {} 
    574                     self.model._persistency_dict[p] = \ 
    575                                                     [self.values, self.weights] 
    576                     self.state.model._persistency_dict[p] = \ 
    577                                                     [self.values,self.weights] 
    578                 else: 
    579                     self._reset_dispersity() 
    580                
    581                 ## Redraw the model 
    582                 self._draw_model() 
    583          
    584         ## post state to fit panel 
    585         event = PageInfoEvent(page = self) 
    586         wx.PostEvent(self.parent, event) 
    587         
    588474     
    589475    def onResetModel(self, event): 
    … …  
    603489            previous_state = self.saved_states[name] 
    604490            ## reset state of checkbox,textcrtl  and  regular parameters value 
    605             self.reset_page(previous_state)       
     491            self.reset_page(previous_state)    
     492                
     493    def on_report_state(self, event): 
     494        """ 
     495        Report the current fit results 
     496        """    
     497        event.Skip() 
     498        # Get plot image from plotpanel 
     499        images, canvases = self.get_images() 
     500        # get the report dialog 
     501        self.state.report(images, canvases) 
     502         
    606503          
    607504    def on_save(self, event):    
    … …  
    785682        self.state.qmax_x = self.qmax_x 
    786683        self.state.qmin_x = self.qmin_x 
    787         try: 
    788             n = self.disp_box.GetCurrentSelection() 
    789             dispersity= self.disp_box.GetClientData(n) 
    790             name= dispersity.__name__ 
    791             self.disp_name = name 
    792             if name == "GaussianDispersion" : 
    793                if hasattr(self,"cb1"): 
    794                    self.state.cb1= self.cb1.GetValue() 
    795         except: 
    796             pass 
    797684       
    798685        if hasattr(self,"enable_disp"): 
    … …  
    811698        self.state.slit_smearer = copy.deepcopy(self.slit_smearer.GetValue())   
    812699                   
    813         if hasattr(self,"disp_box"): 
    814             self.state.disp_box = self.disp_box.GetSelection() 
    815  
    816             if len(self.disp_cb_dict)>0: 
    817                 for k , v in self.disp_cb_dict.iteritems(): 
    818           
    819                     if v ==None : 
    820                         self.state.disp_cb_dict[k]= v 
    821                     else: 
    822                         try: 
    823                             self.state.disp_cb_dict[k]=v.GetValue() 
    824                         except: 
    825                             self.state.disp_cb_dict[k]= None 
    826             
    827             if len(self._disp_obj_dict)>0: 
    828                 for k , v in self._disp_obj_dict.iteritems(): 
    829        
    830                     self.state._disp_obj_dict[k]= v 
     700        if len(self._disp_obj_dict)>0: 
     701            for k , v in self._disp_obj_dict.iteritems(): 
     702                self.state._disp_obj_dict[k]= v 
    831703                         
    832704             
    … …  
    836708        self._save_plotting_range() 
    837709         
    838         self.state.orientation_params =[] 
    839         self.state.orientation_params_disp =[] 
    840         self.state.parameters =[] 
    841         self.state.fittable_param =[] 
    842         self.state.fixed_param =[] 
     710        self.state.orientation_params = [] 
     711        self.state.orientation_params_disp = [] 
     712        self.state.parameters = [] 
     713        self.state.fittable_param = [] 
     714        self.state.fixed_param = [] 
     715        self.state.str_parameters = [] 
    843716 
    844717         
    845718        ## save checkbutton state and txtcrtl values 
     719        self._copy_parameters_state(self.str_parameters,  
     720                                    self.state.str_parameters) 
    846721        self._copy_parameters_state(self.orientation_params, 
    847722                                     self.state.orientation_params) 
    … …  
    873748        ## save data     
    874749        self.state.data= copy.deepcopy(self.data) 
    875         try: 
    876             n = self.disp_box.GetCurrentSelection() 
    877             dispersity= self.disp_box.GetClientData(n) 
    878             name= dispersity.__name__ 
    879             self.disp_name = name 
    880             if name == "GaussianDispersion" : 
    881                if hasattr(self,"cb1"): 
    882                    self.state.cb1= self.cb1.GetValue() 
    883  
    884         except: 
    885             pass 
    886750         
    887751        if hasattr(self,"enable_disp"): 
    … …  
    1065929            #self._undo.Enable(False) 
    1066930            return  
    1067      
     931        # set data, etc. from the state 
    1068932        self.set_data(state.data) 
    1069933        self.enable2D= state.enable2D 
    … …  
    1108972        self.enable_disp.SetValue(state.enable_disp) 
    1109973        self.disable_disp.SetValue(state.disable_disp) 
    1110          
    1111         if hasattr(self, "disp_box"): 
    1112              
    1113             self.disp_box.SetSelection(state.disp_box)  
    1114             n= self.disp_box.GetCurrentSelection() 
    1115             dispersity= self.disp_box.GetClientData(n) 
    1116             name = dispersity.__name__      
    1117  
     974        # If the polydispersion is ON 
     975        if state.enable_disp: 
     976            # reset dispersion according the state 
    1118977            self._set_dipers_Param(event=None) 
    1119         
    1120             if name == "ArrayDispersion": 
    1121                  
    1122                 for item in self.disp_cb_dict.keys(): 
    1123                      
    1124                     if hasattr(self.disp_cb_dict[item], "SetValue") : 
    1125                         self.disp_cb_dict[item].SetValue(\ 
    1126                                                     state.disp_cb_dict[item]) 
    1127                         # Create the dispersion objects 
    1128                         from sans.models.dispersion_models import ArrayDispersion 
    1129                         disp_model = ArrayDispersion() 
    1130                         if hasattr(state,"values")and\ 
    1131                                  self.disp_cb_dict[item].GetValue() == True: 
    1132                             if len(state.values)>0: 
    1133                                 self.values=state.values 
    1134                                 self.weights=state.weights 
    1135                                 disp_model.set_weights(self.values, 
    1136                                                         state.weights) 
    1137                             else: 
    1138                                 self._reset_dispersity() 
    1139                          
    1140                         self._disp_obj_dict[item] = disp_model 
    1141                         # Set the new model as the dispersion object  
    1142                         #for the selected parameter 
    1143                         self.model.set_dispersion(item, disp_model) 
    1144                      
    1145                         self.model._persistency_dict[item] = \ 
    1146                                                 [state.values, state.weights] 
    1147                      
    1148             else: 
    1149                 keys = self.model.getParamList() 
    1150                 for item in keys: 
    1151                     if item in self.disp_list and \ 
    1152                         not self.model.details.has_key(item): 
    1153                         self.model.details[item] = ["", None, None] 
    1154                 for k,v in self.state.disp_cb_dict.iteritems(): 
    1155                     self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)  
    1156                     self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    1157  
     978            self._reset_page_disp_helper(state) 
    1158979        ##plotting range restore     
    1159980        self._reset_plotting_range(state) 
    … …  
    11851006        self.state = state.clone()  
    11861007     
    1187          
    1188     def old_reset_page_helper(self, state): 
    1189         """ 
    1190         Use page_state and change the state of existing page 
    1191          
    1192         :precondition: the page is already drawn or created 
    1193          
    1194         :postcondition: the state of the underlying data change as well as the 
    1195             state of the graphic interface 
    1196         """ 
    1197         if state ==None: 
    1198             #self._undo.Enable(False) 
    1199             return  
    1200         
    1201         self.model= state.model 
    1202         self.data = state.data 
    1203         if self.data !=None: 
    1204             from DataLoader.qsmearing import smear_selection 
    1205             self.smearer= smear_selection(self.data, self.model) 
    1206         self.enable2D= state.enable2D 
    1207         self.engine_type = state.engine_type 
    1208  
    1209         self.disp_cb_dict = state.disp_cb_dict 
    1210         self.disp_list = state.disp_list 
    1211  
    1212         ## set the state of the radio box 
    1213         self.shape_rbutton.SetValue(state.shape_rbutton ) 
    1214         self.shape_indep_rbutton.SetValue(state.shape_indep_rbutton) 
    1215         self.struct_rbutton.SetValue(state.struct_rbutton ) 
    1216         self.plugin_rbutton.SetValue(state.plugin_rbutton) 
    1217         ##draw sizer containing model parameters value for the current model 
    1218         self._set_model_sizer_selection( self.model ) 
    1219         self.set_model_param_sizer(self.model) 
    1220  
    1221         ## reset value of combox box 
    1222         self.structurebox.SetSelection(state.structurecombobox ) 
    1223         self.formfactorbox.SetSelection(state.formfactorcombobox) 
    1224          
    1225          
    1226         ## enable the view 2d button if this is a modelpage type 
    1227         if hasattr(self,"model_view"): 
    1228             if self.enable2D: 
    1229                 self.model_view.Disable() 
     1008    def _reset_page_disp_helper(self, state): 
     1009        """ 
     1010        Help to rest page for dispersions 
     1011        """ 
     1012        keys = self.model.getParamList() 
     1013        for item in keys: 
     1014            if item in self.disp_list and \ 
     1015                not self.model.details.has_key(item): 
     1016                self.model.details[item] = ["", None, None] 
     1017        #for k,v in self.state.disp_cb_dict.iteritems(): 
     1018        self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)  
     1019        self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
     1020        self.values = copy.deepcopy(state.values) 
     1021        self.weights = copy.deepcopy(state.weights) 
     1022         
     1023        for key, disp in state._disp_obj_dict.iteritems(): 
     1024            # From saved file, disp_model can not be sent in model obj. 
     1025            # it will be sent as a string here, then converted to model object. 
     1026            if disp.__class__.__name__ == 'str': 
     1027                com_str  = "from sans.models.dispersion_models " 
     1028                com_str += "import %s as disp_func" 
     1029                exec com_str % disp 
     1030                disp_model = disp_func() 
    12301031            else: 
    1231                 self.model_view.Enable() 
    1232         ## set the select all check box to the a given state 
    1233         if hasattr(self, "cb1"):    
    1234             self.cb1.SetValue(state.cb1) 
    1235       
    1236         ## reset state of checkbox,textcrtl  and  regular parameters value 
    1237              
    1238         self._reset_parameters_state(self.orientation_params_disp, 
    1239                                      state.orientation_params_disp) 
    1240         self._reset_parameters_state(self.orientation_params, 
    1241                                      state.orientation_params) 
    1242         self._reset_parameters_state(self.parameters,state.parameters)     
    1243          ## display dispersion info layer         
    1244         self.enable_disp.SetValue(state.enable_disp) 
    1245         self.disable_disp.SetValue(state.disable_disp) 
    1246          
    1247         if hasattr(self, "disp_box"): 
    1248              
    1249             self.disp_box.SetSelection(state.disp_box)  
    1250             n= self.disp_box.GetCurrentSelection() 
    1251             dispersity= self.disp_box.GetClientData(n) 
    1252             name= dispersity.__name__      
    1253  
    1254             self._set_dipers_Param(event=None) 
    1255         
    1256             if name=="ArrayDispersion": 
    1257                  
    1258                 for item in self.disp_cb_dict.keys(): 
    1259                      
    1260                     if hasattr(self.disp_cb_dict[item],"SetValue") : 
    1261                         self.disp_cb_dict[item].SetValue(state.disp_cb_dict[item]) 
    1262                         # Create the dispersion objects 
    1263                         from sans.models.dispersion_models import ArrayDispersion 
    1264                         disp_model = ArrayDispersion() 
    1265                         if hasattr(state,"values") and\ 
    1266                              self.disp_cb_dict[item].GetValue()==True: 
    1267                             if len(state.values) > 0: 
    1268                                 self.values = state.values 
    1269                                 self.weights = state.weights 
    1270                                 disp_model.set_weights(self.values, 
    1271                                                         state.weights) 
    1272                             else: 
    1273                                 self._reset_dispersity() 
    1274                          
    1275                         self._disp_obj_dict[item] = disp_model 
    1276                         # Set the new model as the dispersion 
    1277                         #object for the selected parameter 
    1278                         self.model.set_dispersion(item, disp_model) 
    1279                      
    1280                         self.model._persistency_dict[item] = [state.values, 
    1281                                                                state.weights] 
    1282                      
    1283             else: 
    1284                 keys = self.model.getParamList() 
    1285                 for item in keys: 
    1286                     if item in self.disp_list and \ 
    1287                             not self.model.details.has_key(item): 
    1288                         self.model.details[item]=["",None,None] 
    1289                 for k,v in self.state.disp_cb_dict.iteritems(): 
    1290                     self.disp_cb_dict = copy.deepcopy(state.disp_cb_dict)  
    1291                     self.state.disp_cb_dict = copy.deepcopy(state.disp_cb_dict) 
    1292  
    1293         ##plotting range restore     
    1294         self._reset_plotting_range(state) 
    1295  
    1296         ## smearing info  restore 
    1297         if hasattr(self,"enable_smearer"): 
    1298             ## set smearing value whether or not the data  
    1299             #contain the smearing info 
    1300             self.enable_smearer.SetValue(state.enable_smearer) 
    1301             self.disable_smearer.SetValue(state.disable_smearer) 
    1302             self.onSmear(event=None)            
    1303         self.pinhole_smearer.SetValue(state.pinhole_smearer) 
    1304         self.slit_smearer.SetValue(state.slit_smearer) 
    1305         ## we have two more options for smearing 
    1306         if self.pinhole_smearer.GetValue(): self.onPinholeSmear(event=None) 
    1307         elif self.slit_smearer.GetValue(): self.onSlitSmear(event=None) 
    1308         
    1309         ## reset state of checkbox,textcrtl  and dispersity parameters value 
    1310         self._reset_parameters_state(self.fittable_param,state.fittable_param) 
    1311         self._reset_parameters_state(self.fixed_param,state.fixed_param) 
    1312          
    1313         ## draw the model with previous parameters value 
    1314         self._onparamEnter_helper() 
    1315          
    1316         ## reset context menu items 
    1317         self._reset_context_menu() 
    1318      
    1319         ## set the value of the current state to the state given as parameter 
    1320         self.state = state.clone()  
    1321         self._draw_model() 
    1322  
     1032                disp_model = disp 
     1033 
     1034            self._disp_obj_dict[key] = disp_model  
     1035            param_name = key.split('.')[0] 
     1036            # Try to set dispersion only when available 
     1037            # for eg., pass the orient. angles for 1D Cal  
     1038            try: 
     1039                self.model.set_dispersion(param_name, disp_model) 
     1040                self.model._persistency_dict[key] = \ 
     1041                                 [state.values, state.weights] 
     1042            except: 
     1043                pass 
     1044            selection = self._find_polyfunc_selection(disp_model) 
     1045            for list in self.fittable_param: 
     1046                if list[1] == key and list[7] != None: 
     1047                    list[7].SetSelection(selection) 
     1048                    # For the array disp_model, set the values and weights  
     1049                    if selection == 1: 
     1050                        disp_model.set_weights(self.values[key],  
     1051                                              self.weights[key]) 
     1052                        try: 
     1053                            # Diables all fittable params for array 
     1054                            list[0].SetValue(False) 
     1055                            list[0].Disable() 
     1056                            list[2].Disable() 
     1057                            list[5].Disable() 
     1058                            list[6].Disable() 
     1059                        except: 
     1060                            pass 
     1061            # For array, disable all fixed params 
     1062            if selection == 1: 
     1063                for item in self.fixed_param: 
     1064                    if item[1].split(".")[0] == key.split(".")[0]: 
     1065                        # try it and pass it for the orientation for 1D 
     1066                        try: 
     1067                            item[2].Disable() 
     1068                        except: 
     1069                            pass 
     1070     
     1071        # Make sure the check box updated when all checked 
     1072        if self.cb1.GetValue(): 
     1073            self.select_all_param(None)         
     1074       
    13231075    def _selectDlg(self): 
    13241076        """ 
    … …  
    15451297            if item_page[2]!=None: 
    15461298                item_page[2].SetValue(item_page_info[2]) 
     1299                if item_page[2].__class__.__name__ == "ComboBox": 
     1300                   if self.model.fun_list.has_key(item_page_info[2]): 
     1301                       fun_val = self.model.fun_list[item_page_info[2]] 
     1302                       self.model.setParam(item_page_info[1],fun_val) 
    15471303            if item_page[3]!=None: 
    15481304                ## show or hide text +/- 
    … …  
    15601316            if item_page[5]!=None: 
    15611317                ## show of hide the text crtl for fitting error 
    1562                 if item_page_info[5][0]: 
    1563                     item_page[5].Show(True) 
    1564                     item_page[5].SetValue(item_page_info[5][1]) 
    1565                 else: 
    1566                     item_page[5].Hide() 
    1567                      
     1318                item_page[5].Show(item_page_info[5][0]) 
     1319                item_page[5].SetValue(item_page_info[5][1]) 
     1320                 
    15681321            if item_page[6]!=None: 
    15691322                ## show of hide the text crtl for fitting error 
    1570                 if item_page_info[6][0]: 
    1571                     item_page[6].Show(True) 
    1572                     item_page[6].SetValue(item_page_info[6][1]) 
    1573                 else: 
    1574                     item_page[6].Hide() 
     1323                item_page[6].Show(item_page_info[6][0]) 
     1324                item_page[6].SetValue(item_page_info[6][1]) 
     1325 
     1326                     
     1327    def _reset_strparam_state(self, listtorestore, statelist): 
     1328        """ 
     1329        Reset the string parameters at the given state 
     1330        """ 
     1331        if len(statelist) == 0: 
     1332            return 
     1333 
     1334        listtorestore = copy.deepcopy(statelist) 
     1335         
     1336        for j in range(len(listtorestore)): 
     1337            item_page = listtorestore[j] 
     1338            item_page_info = statelist[j] 
     1339            ##change the state of the check box for simple parameters 
     1340             
     1341            if item_page[0] != None:    
     1342                item_page[0].SetValue(format_number(item_page_info[0], True)) 
     1343 
     1344            if item_page[2] != None: 
     1345                param_name = item_page_info[1] 
     1346                value = item_page_info[2] 
     1347                selection = value 
     1348                if self.model.fun_list.has_key(value): 
     1349                    selection = self.model.fun_list[value] 
     1350                item_page[2].SetValue(selection) 
     1351                self.model.setParam(param_name, selection) 
    15751352                                       
    15761353    def _copy_parameters_state(self, listtocopy, statelist): 
    … …  
    17391516                    break 
    17401517     
    1741     def _draw_model(self): 
     1518    def _draw_model(self, update_chisqr=True): 
    17421519        """ 
    17431520        Method to draw or refresh a plotted model. 
    17441521        The method will use the data member from the model page 
    17451522        to build a call to the fitting perspective manager. 
     1523         
     1524        :param chisqr: update chisqr value [bool] 
    17461525        """ 
    17471526        #if self.check_invalid_panel(): 
    … …  
    17621541                                    toggle_mode_on=toggle_mode_on,  
    17631542                                    state = self.state, 
    1764                                     enable2D=self.enable2D) 
     1543                                    enable2D=self.enable2D, 
     1544                                    update_chisqr=update_chisqr) 
    17651545         
    17661546        
    … …  
    21711951            name = str(item[1]) 
    21721952             
    2173             if string.find(name,".npts") ==-1 and string.find(name,".nsigmas")==-1:       
     1953            if string.find(name,".npts") ==-1 and \ 
     1954                                        string.find(name,".nsigmas")==-1:       
    21741955                ## check model parameters range              
    21751956                param_min= None 
    … …  
    21911972                        except: 
    21921973                            msg = "Wrong Fit parameter range entered " 
    2193                             wx.PostEvent(self.parent.parent, StatusEvent(status = msg)) 
     1974                            wx.PostEvent(self.parent.parent,  
     1975                                         StatusEvent(status = msg)) 
    21941976                            raise ValueError, msg 
    21951977                        is_modified = True 
    … …  
    22071989                        except: 
    22081990                            msg = "Wrong Fit parameter range entered " 
    2209                             wx.PostEvent(self.parent.parent, StatusEvent(status = msg)) 
     1991                            wx.PostEvent(self.parent.parent,  
     1992                                         StatusEvent(status = msg)) 
    22101993                            raise ValueError, msg 
    22111994                        is_modified = True 
    … …  
    22161999                        msg= "Wrong Fit range entered for parameter " 
    22172000                        msg+= "name %s of model %s "%(name, self.model.name) 
    2218                         wx.PostEvent(self.parent.parent, StatusEvent(status = msg)) 
     2001                        wx.PostEvent(self.parent.parent,  
     2002                                     StatusEvent(status = msg)) 
    22192003                 
    22202004                if name in self.model.details.keys():    
    2221                         self.model.details[name][1:3]= param_min,param_max 
     2005                        self.model.details[name][1:3] = param_min, param_max 
    22222006                        is_modified = True 
    22232007               
    22242008                else: 
    2225                         self.model.details [name] = ["",param_min,param_max]  
     2009                        self.model.details [name] = ["", param_min, param_max]  
    22262010                        is_modified = True 
    2227             try:      
    2228                 value= float(item[2].GetValue()) 
    2229                 item[2].SetBackgroundColour("white") 
    2230                 # If the value of the parameter has changed, 
    2231                 # +update the model and set the is_modified flag 
    2232                 if value != self.model.getParam(name) and numpy.isfinite(value): 
    2233                     self.model.setParam(name,value) 
    2234                     is_modified = True    
     2011            try:    
     2012                # Check if the textctr is enabled 
     2013                if item[2].IsEnabled(): 
     2014                    value= float(item[2].GetValue()) 
     2015                    item[2].SetBackgroundColour("white") 
     2016                    # If the value of the parameter has changed, 
     2017                    # +update the model and set the is_modified flag 
     2018                    if value != self.model.getParam(name) and \ 
     2019                                                numpy.isfinite(value): 
     2020                        self.model.setParam(name, value) 
     2021                         
    22352022            except: 
    22362023                item[2].SetBackgroundColour("pink") 
    … …  
    22642051        if self.model ==None: 
    22652052            self.model_disp.Hide() 
    2266             self.disp_box.Hide() 
    22672053            self.sizer4_4.Clear(True) 
    22682054            return 
    22692055 
    22702056        if self.enable_disp.GetValue(): 
    2271             self.model_disp.Show(True) 
    2272             self.disp_box.Show(True) 
    22732057            ## layout for model containing no dispersity parameters 
    22742058             
    … …  
    22812065                self._on_select_Disp(event=None) 
    22822066        else: 
    2283             self.model_disp.Hide() 
    2284             self.disp_box.Hide() 
    2285             self.disp_box.SetSelection(0)  
    22862067            self.sizer4_4.Clear(True) 
    22872068             
    … …  
    23102091        self.orientation_params_disp=[] 
    23112092         
    2312         self.model_disp.Hide() 
    2313         self.disp_box.Hide() 
    23142093        self.sizer4_4.Clear(True) 
    23152094        text = "No polydispersity available for this model" 
     2095        text = "No polydispersity available for this model" 
    23162096        model_disp = wx.StaticText(self, -1, text) 
    2317         self.sizer4_4.Add(model_disp,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
     2097        self.sizer4_4.Add(model_disp,( iy, ix),(1,1),   
     2098                            wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 10) 
    23182099        self.sizer4_4.Layout() 
    23192100        self.sizer4.Layout() 
    … …  
    23352116        self.fixed_param=[] 
    23362117        self.orientation_params_disp=[] 
    2337         self.values=[] 
    2338         self.weights=[] 
     2118        self.values={} 
     2119        self.weights={} 
    23392120       
    23402121        from sans.models.dispersion_models import GaussianDispersion, ArrayDispersion 
    … …  
    23682149        self.disp_list should change type later .now only gaussian 
    23692150        """ 
    2370         n = self.disp_box.GetCurrentSelection() 
    2371         name = self.disp_box.GetValue() 
    2372         dispersity= self.disp_box.GetClientData(n) 
    2373         self.disp_name = name 
    2374          
    2375         if name.lower() == "array": 
    2376             self._set_sizer_arraydispersion() 
    2377         else: 
    2378             self._set_sizer_dispersion(dispersity= dispersity) 
    2379              
    2380         self.state.disp_box= n 
     2151        self._set_sizer_dispersion() 
     2152 
    23812153        ## Redraw the model 
    23822154        self._draw_model()  
    … …  
    23892161        self.SetupScrolling() 
    23902162     
    2391     def _set_sizer_arraydispersion(self): 
    2392         """ 
    2393         draw sizer with array dispersity  parameters 
    2394         """ 
    2395          
     2163    def _on_disp_func(self, event=None):  
     2164        """ 
     2165        Select a distribution function for the polydispersion 
     2166         
     2167        :Param event: ComboBox event  
     2168        """ 
     2169        # get ready for new event 
     2170        if event != None: 
     2171            event.Skip() 
     2172        # Get event object 
     2173        disp_box =  event.GetEventObject()  
     2174 
     2175        # Try to select a Distr. function 
     2176        try:    
     2177            disp_box.SetBackgroundColour("white") 
     2178            selection = disp_box.GetCurrentSelection() 
     2179            param_name = disp_box.Name.split('.')[0] 
     2180            disp_name = disp_box.GetValue() 
     2181            dispersity= disp_box.GetClientData(selection) 
     2182     
     2183            #disp_model =  GaussianDispersion() 
     2184            disp_model = dispersity() 
     2185            # Get param names to reset the values of the param 
     2186            name1 = param_name + ".width" 
     2187            name2 = param_name + ".npts" 
     2188            name3 = param_name + ".nsigmas" 
     2189            # Check Disp. function whether or not it is 'array' 
     2190            if disp_name.lower() == "array": 
     2191                value2= "" 
     2192                value3= "" 
     2193                value1 = self._set_array_disp(name=name1, disp=disp_model) 
     2194            else: 
     2195                self._del_array_values(name1) 
     2196                #self._reset_array_disp(param_name) 
     2197                self._disp_obj_dict[name1] = disp_model 
     2198                self.model.set_dispersion(param_name, disp_model) 
     2199                self.state._disp_obj_dict[name1]= disp_model 
     2200  
     2201                value1= str(format_number(self.model.getParam(name1), True)) 
     2202                value2= str(format_number(self.model.getParam(name2))) 
     2203                value3= str(format_number(self.model.getParam(name3))) 
     2204            # Reset fittable polydispersin parameter value 
     2205            for item in self.fittable_param: 
     2206                 if item[1] == name1: 
     2207                    item[2].SetValue(value1)  
     2208                    item[5].SetValue("") 
     2209                    item[6].SetValue("") 
     2210                    # Disable for array 
     2211                    if disp_name.lower() == "array": 
     2212                        item[0].SetValue(False) 
     2213                        item[0].Disable() 
     2214                        item[2].Disable() 
     2215                        item[5].Disable() 
     2216                        item[6].Disable() 
     2217                    else: 
     2218                        item[0].Enable() 
     2219                        item[2].Enable() 
     2220                        item[5].Enable() 
     2221                        item[6].Enable()                        
     2222                    break 
     2223            # Reset fixed polydispersion params 
     2224            for item in self.fixed_param: 
     2225                if item[1] == name2: 
     2226                    item[2].SetValue(value2)  
     2227                    # Disable Npts for array 
     2228                    if disp_name.lower() == "array": 
     2229                        item[2].Disable() 
     2230                    else: 
     2231                        item[2].Enable() 
     2232                if item[1] == name3: 
     2233                    item[2].SetValue(value3)  
     2234                    # Disable Nsigs for array 
     2235                    if disp_name.lower() == "array": 
     2236                        item[2].Disable() 
     2237                    else: 
     2238                        item[2].Enable() 
     2239                 
     2240            # Make sure the check box updated when all checked 
     2241            if self.cb1.GetValue(): 
     2242                self.select_all_param(None) 
     2243 
     2244            # update params 
     2245            self._update_paramv_on_fit()  
     2246            # draw 
     2247            self._draw_model() 
     2248            self.Refresh() 
     2249        except: 
     2250            # Error msg 
     2251            msg = "Error occurred:" 
     2252            msg += " Could not select the distribution function..." 
     2253            msg += " Please select another distribution function." 
     2254            disp_box.SetBackgroundColour("pink") 
     2255            # Focus on Fit button so that users can see the pinky box 
     2256            self.btFit.SetFocus() 
     2257            wx.PostEvent(self.parent.parent,  
     2258                         StatusEvent(status=msg, info="error")) 
     2259         
     2260         
     2261    def _set_array_disp(self, name=None, disp=None): 
     2262        """ 
     2263        Set array dispersion 
     2264         
     2265        :param name: name of the parameter for the dispersion to be set 
     2266        :param disp: the polydisperion object 
     2267        """ 
     2268        # The user wants this parameter to be averaged.  
     2269        # Pop up the file selection dialog. 
     2270        path = self._selectDlg() 
     2271        # Array data 
     2272        values = [] 
     2273        weights = [] 
     2274        # If nothing was selected, just return 
     2275        if path is None: 
     2276            self.disp_cb_dict[name].SetValue(False) 
     2277            #self.noDisper_rbox.SetValue(True) 
     2278            return 
     2279        self._default_save_location = os.path.dirname(path) 
     2280 
     2281        basename  = os.path.basename(path) 
     2282        values,weights = self.read_file(path) 
     2283         
     2284        # If any of the two arrays is empty, notify the user that we won't 
     2285        # proceed 
    23962286        if len(self.param_toFit)>0: 
    2397             for item in self.fittable_param: 
    2398                 if item in self.param_toFit: 
    2399                     self.param_toFit.remove(item) 
    2400             for item in self.orientation_params_disp: 
    2401                 if item in self.param_toFit: 
    2402                     self.param_toFit.remove(item) 
    2403         for item in self.model.details.keys(): 
    2404             if item in self.model.fixed: 
    2405                 del self.model.details [item]                            
    2406  
    2407         self.fittable_param=[] 
    2408         self.fixed_param=[] 
    2409         self.orientation_params_disp=[] 
    2410         self.sizer4_4.Clear(True)  
    2411         self._reset_dispersity() 
    2412         ix=0 
    2413         iy=1      
    2414         disp1 = wx.StaticText(self, -1, 'Array Dispersion') 
    2415         self.sizer4_4.Add(disp1,( iy, ix),(1,1),  wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
    2416          
    2417         # Look for model parameters to which we can apply an ArrayDispersion model 
    2418         # Add a check box for each parameter. 
    2419         self.disp_cb_dict = {} 
    2420         ix+=1  
    2421         self.noDisper_rbox = wx.RadioButton(self, -1,"None", (10, 10),style= wx.RB_GROUP) 
    2422         self.Bind(wx.EVT_RADIOBUTTON,self.select_disp_angle , id=self.noDisper_rbox.GetId()) 
    2423         #MAC needs SetValue 
    2424         self.noDisper_rbox.SetValue(True) 
    2425         self.sizer4_4.Add(self.noDisper_rbox, (iy, ix), 
    2426                            (1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    2427          
    2428         for p in self.model.dispersion.keys(): 
    2429             if not p in self.model.orientation_params: 
    2430                 ix+=1  
    2431                 self.disp_cb_dict[p] = wx.RadioButton(self, -1, p, (10, 10)) 
    2432                 self.state.disp_cb_dict[p]=  self.disp_cb_dict[p].GetValue() 
    2433                 self.Bind(wx.EVT_RADIOBUTTON, self.select_disp_angle, id=self.disp_cb_dict[p].GetId()) 
    2434                 self.sizer4_4.Add(self.disp_cb_dict[p], (iy, ix), (1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    2435          
    2436         for p in self.model.dispersion.keys(): 
    2437             if p in self.model.orientation_params: 
    2438                 ix+=1  
    2439                 self.disp_cb_dict[p] = wx.RadioButton(self, -1, p, (10, 10)) 
    2440                 self.state.disp_cb_dict[p]=  self.disp_cb_dict[p].GetValue() 
    2441                 if not (self.enable2D or self.data.__class__.__name__ =="Data2D"): 
    2442                     self.disp_cb_dict[p].Hide() 
    2443                 else: 
    2444                     self.disp_cb_dict[p].Show(True) 
    2445                 self.Bind(wx.EVT_RADIOBUTTON, self.select_disp_angle, id=self.disp_cb_dict[p].GetId()) 
    2446                 self.sizer4_4.Add(self.disp_cb_dict[p], (iy, ix), (1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    2447  
    2448  
    2449         ix =0 
    2450         iy +=1  
    2451         self.sizer4_4.Add((20,20),(iy,ix),(1,1), wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15)         
    2452         self.Layout() 
    2453  
    2454         self.state.orientation_params =[] 
    2455         self.state.orientation_params_disp =[] 
    2456         self.state.parameters =[] 
    2457         self.state.fittable_param =[] 
    2458         self.state.fixed_param =[] 
    2459          
    2460         ## save checkbutton state and txtcrtl values 
    2461          
    2462         self._copy_parameters_state(self.orientation_params, 
    2463                                      self.state.orientation_params) 
    2464  
    2465         self._copy_parameters_state(self.orientation_params_disp, 
    2466                                      self.state.orientation_params_disp) 
    2467          
    2468         self._copy_parameters_state(self.parameters, self.state.parameters) 
    2469         self._copy_parameters_state(self.fittable_param, self.state.fittable_param) 
    2470         self._copy_parameters_state(self.fixed_param, self.state.fixed_param) 
    2471          
    2472          
    2473         ## post state to fit panel 
    2474         event = PageInfoEvent(page = self) 
    2475         wx.PostEvent(self.parent, event) 
    2476     
     2287            if name in self.param_toFit: 
     2288                self.param_toFit.remove(name) 
     2289 
     2290        # Tell the user that we are about to apply the distribution 
     2291        msg = "Applying loaded %s distribution: %s" % (name, path) 
     2292        wx.PostEvent(self.parent.parent, StatusEvent(status=msg))   
     2293 
     2294        disp.set_weights(values, weights) 
     2295        self._disp_obj_dict[name] = disp 
     2296        self.model.set_dispersion(name.split('.')[0], disp) 
     2297        self.state._disp_obj_dict[name]= disp 
     2298        self.values[name] = values 
     2299        self.weights[name] = weights 
     2300        # Store the object to make it persist outside the 
     2301        # scope of this method 
     2302        #TODO: refactor model to clean this up? 
     2303        self.state.values = {} 
     2304        self.state.weights = {} 
     2305        self.state.values = copy.deepcopy(self.values) 
     2306        self.state.weights = copy.deepcopy(self.weights) 
     2307 
     2308        # Set the new model as the dispersion object for the  
     2309        #selected parameter 
     2310        #self.model.set_dispersion(p, disp_model) 
     2311        # Store a reference to the weights in the model object  
     2312        #so that 
     2313        # it's not lost when we use the model within another thread. 
     2314        #TODO: total hack - fix this 
     2315        self.state.model= self.model.clone() 
     2316        self.model._persistency_dict[name.split('.')[0]] = \ 
     2317                                        [values, weights] 
     2318        self.state.model._persistency_dict[name.split('.')[0]] = \ 
     2319                                        [values,weights] 
     2320        return basename 
     2321     
     2322    def _del_array_values(self, name=None):   
     2323        """ 
     2324        Reset array dispersion 
     2325         
     2326        :param name: name of the parameter for the dispersion to be set  
     2327        """ 
     2328        # Try to delete values and weight of the names array dic if exists 
     2329        try: 
     2330            del self.values[name] 
     2331            del self.weights[name] 
     2332            # delete all other dic 
     2333            del self.state.values[name] 
     2334            del self.state.weights[name] 
     2335            del self.model._persistency_dict[name.split('.')[0]]  
     2336            del self.state.model._persistency_dict[name.split('.')[0]] 
     2337        except: 
     2338            pass 
     2339                                             
    24772340    def _lay_out(self): 
    24782341        """ 
    … …  
    24942357            time.sleep(1) 
    24952358             
     2359    def _find_polyfunc_selection(self, disp_func = None): 
     2360        """ 
     2361        FInd Comboox selection from disp_func  
     2362         
     2363        :param disp_function: dispersion distr. function 
     2364        """ 
     2365        # List of the poly_model name in the combobox 
     2366        list = ["RectangleDispersion", "ArrayDispersion",  
     2367                    "LogNormalDispersion", "GaussianDispersion",  
     2368                    "SchulzDispersion"] 
     2369 
     2370        # Find the selection 
     2371        try: 
     2372            selection = list.index(disp_func.__class__.__name__) 
     2373            return selection 
     2374        except: 
     2375             return 3 
     2376                             
    24962377    def on_reset_clicked(self,event): 
    24972378        """ 
    … …  
    25562437        #Re draw plot 
    25572438        self._draw_model() 
     2439         
     2440    def get_images(self): 
     2441        """ 
     2442        Get the images of the plots corresponding this panel for report 
     2443         
     2444        : return graphs: list of figures 
     2445        : TODO: Move to guiframe 
     2446        """ 
     2447        # set list of graphs 
     2448        graphs = [] 
     2449        canvases = [] 
     2450        # call gui_manager 
     2451        gui_manager = self.parent.parent 
     2452        # loops through the panels [dic] 
     2453        for item1, item2 in gui_manager.panels.iteritems(): 
     2454             data_title = self.data.group_id 
     2455             data_name = self.data.name 
     2456            # try to get all plots belonging to this control panel 
     2457             try: 
     2458                 # check titles (main plot)  
     2459                 # and data_names (model plot[2D], and residuals) 
     2460                 if item2.group_id == data_title or \ 
     2461                                item2.window_name.count(data_name): 
     2462                     #panel = gui_manager._mgr.GetPane(item2.window_name) 
     2463                     # append to the list 
     2464                     graphs.append(item2.figure)  
     2465                     canvases.append(item2.canvas)      
     2466             except: 
     2467                 # Not for control panels 
     2468                 pass 
     2469        # return the list of graphs 
     2470        return graphs, canvases 
    25582471 
    25592472    def on_model_help_clicked(self,event): 
    … …  
    25622475        """ 
    25632476        from help_panel import  HelpWindow 
    2564          
     2477        import sans.models as models  
     2478         
     2479        # Get models help model_function path 
     2480        path = models.get_data_path(media='media') 
     2481        model_path = os.path.join(path,"model_functions.html") 
    25652482        if self.model == None: 
    25662483            name = 'FuncHelp' 
    … …  
    25682485            name = self.model.origin_name 
    25692486 
    2570         frame = HelpWindow(None, -1,  pageToOpen="media/model_functions.html")     
     2487        frame = HelpWindow(None, -1,  pageToOpen=model_path)     
    25712488        frame.Show(True) 
    25722489        if frame.rhelp.HasAnchor(name): 
    … …  
    25752492           msg= "Model does not contains an available description " 
    25762493           msg +="Please try searching in the Help window" 
    2577            wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))                     
     2494           wx.PostEvent(self.parent.parent, StatusEvent(status = msg ))       
     2495     
     2496    def on_pd_help_clicked(self, event): 
     2497        """ 
     2498        Button event for PD help 
     2499        """ 
     2500        from help_panel import  HelpWindow 
     2501        import sans.models as models  
     2502         
     2503        # Get models help model_function path 
     2504        path = models.get_data_path(media='media') 
     2505        pd_path = os.path.join(path,"pd_help.html") 
     2506 
     2507        frame = HelpWindow(None, -1,  pageToOpen=pd_path)     
     2508        frame.Show(True) 
     2509         
     2510    def on_left_down(self, event): 
     2511        """ 
     2512        Get key stroke event 
     2513        """ 
     2514        # Figuring out key combo: Cmd for copy, Alt for paste 
     2515        if event.CmdDown() and event.ShiftDown(): 
     2516            flag = self.get_paste() 
     2517        elif event.CmdDown(): 
     2518            flag = self.get_copy() 
     2519        else: 
     2520            event.Skip() 
     2521            return 
     2522        # make event free 
     2523        event.Skip() 
     2524        # messages depending on the flag 
     2525        if flag == None: 
     2526            msg = " Parameter values are copied to the clipboard..." 
     2527            infor = 'warning' 
     2528        elif flag: 
     2529            msg = " Parameter values are pasted from the clipboad..." 
     2530            infor = "warning" 
     2531        else: 
     2532            msg = "Error was occured during pasting the parameter values " 
     2533            msg += "from the clipboard..." 
     2534            infor = "error" 
     2535        # inform msg to wx 
     2536        wx.PostEvent( self.parent.parent,  
     2537                      StatusEvent(status= msg, info=infor)) 
     2538         
     2539             
     2540    def get_copy(self):  
     2541        """ 
     2542        Get the string copies of the param names and values in the tap 
     2543        """   
     2544        content = 'sansview_parameter_values:' 
     2545        # Do it if params exist         
     2546        if  self.parameters !=[]: 
     2547             
     2548            # go through the parameters  
     2549            string = self._get_copy_helper(self.parameters,  
     2550                                           self.orientation_params) 
     2551            content += string 
     2552             
     2553            # go through the fittables 
     2554            string = self._get_copy_helper(self.fittable_param,  
     2555                                           self.orientation_params_disp) 
     2556            content += string 
     2557 
     2558            # go through the fixed params 
     2559            string = self._get_copy_helper(self.fixed_param,  
     2560                                           self.orientation_params_disp) 
     2561            content += string 
    25782562                 
     2563            # go through the str params 
     2564            string = self._get_copy_helper(self.str_parameters,  
     2565                                           self.orientation_params) 
     2566            content += string 
     2567 
     2568        if wx.TheClipboard.Open(): 
     2569            wx.TheClipboard.SetData(wx.TextDataObject(str(content))) 
     2570            data = wx.TextDataObject() 
     2571            success = wx.TheClipboard.GetData(data) 
     2572            text = data.GetText() 
     2573            wx.TheClipboard.Close() 
     2574             
     2575        return None 
     2576     
     2577    def _get_copy_helper(self, param, orient_param): 
     2578        """ 
     2579        Helping get value and name of the params 
     2580         
     2581        : param param:  parameters 
     2582        : param orient_param = oritational params 
     2583        : return content: strings [list] [name,value:....] 
     2584        """ 
     2585        content = '' 
     2586        # go through the str params 
     2587        for item in param:  
     2588            # 2D 
     2589            if self.data.__class__.__name__== "Data2D": 
     2590                name = item[1] 
     2591                value = item[2].GetValue() 
     2592            # 1D 
     2593            else: 
     2594                ## for 1D all parameters except orientation 
     2595                if not item[1] in orient_param: 
     2596                    name = item[1] 
     2597                    value = item[2].GetValue() 
     2598            # add to the content 
     2599            content += name + ',' + value + ':' 
     2600             
     2601        return content 
     2602     
     2603    def get_paste(self):  
     2604        """ 
     2605        Get the string copies of the param names and values in the tap 
     2606        """   
     2607        context = {} 
     2608        text = "" 
     2609         
     2610        # Get text from the clip board         
     2611        if wx.TheClipboard.Open(): 
     2612            if wx.TheClipboard.IsSupported(wx.DataFormat(wx.DF_TEXT)): 
     2613                data = wx.TextDataObject() 
     2614                # get wx dataobject 
     2615                success = wx.TheClipboard.GetData(data) 
     2616                # get text 
     2617                text = data.GetText() 
     2618            # close clipboard 
     2619            wx.TheClipboard.Close() 
     2620             
     2621        # put the text into dictionary     
     2622        lines = text.split(':') 
     2623        if lines[0] != 'sansview_parameter_values': 
     2624            return False 
     2625        for line in lines[1:-1]: 
     2626            if len(line) != 0: 
     2627                item =line.split(',') 
     2628                name = item[0] 
     2629                value = item[1] 
     2630                # Transfer the text to content[dictionary] 
     2631                context[name] = value 
     2632         
     2633        # Do it if params exist         
     2634        if  self.parameters != []: 
     2635            # go through the parameters   
     2636            self._get_paste_helper(self.parameters,  
     2637                                   self.orientation_params, context) 
     2638 
     2639            # go through the fittables 
     2640            self._get_paste_helper(self.fittable_param,  
     2641                                   self.orientation_params_disp, context) 
     2642 
     2643            # go through the fixed params 
     2644            self._get_paste_helper(self.fixed_param,  
     2645                                   self.orientation_params_disp, context) 
     2646             
     2647            # go through the str params 
     2648            self._get_paste_helper(self.str_parameters,  
     2649                                   self.orientation_params, context) 
     2650             
     2651        return True 
     2652     
     2653    def _get_paste_helper(self, param, orient_param, content): 
     2654        """ 
     2655        Helping set values of the params 
     2656         
     2657        : param param:  parameters 
     2658        : param orient_param: oritational params 
     2659        : param content: dictionary [ name, value: name1.value1,...]  
     2660        """ 
     2661        # go through the str params 
     2662        for item in param:  
     2663            # 2D 
     2664            if self.data.__class__.__name__== "Data2D": 
     2665                name = item[1] 
     2666                if name in content.keys(): 
     2667                    item[2].SetValue(content[name]) 
     2668            # 1D 
     2669            else: 
     2670                ## for 1D all parameters except orientation 
     2671                if not item[1] in orient_param: 
     2672                    name = item[1] 
     2673                    if name in content.keys(): 
     2674                        # Avoid changing combox content which needs special care 
     2675                        if item[2].__class__.__name__ != "ComboBox": 
     2676                            item[2].SetValue(content[name]) 
     2677                             
     2678                 

  • sansview/perspectives/fitting/console.py

    r66ff250 r2296316  
    116116        """ 
    117117        """ 
    118         #self.elapsed_time = time.time() - self.elapsed_time 
    119         #msg = " Updating fit ...\n result:\n %s \n"%self.result.__str__() 
    120         #wx.PostEvent(self.parent, StatusEvent(status=msg, info="info", 
    121         #                                  type="progress")) 
    122         #if self.manager is not None: 
    123         #    self.manager.update_fit(msg=msg, result=self.result) 
    124         #time.sleep(0.01) 
     118        self.elapsed_time = time.time() - self.elapsed_time 
     119        msg = " Updating fit ...\n result:\n %s \n"%self.result.__str__() 
     120        wx.PostEvent(self.parent, StatusEvent(status=msg, info="info", 
     121                                              type="progress")) 
     122        time.sleep(0.01) 
    125123         
    126124    def starting_fit(self): 

  • sansview/perspectives/fitting/fit_thread.py

    r58e0c83 r2296316  
    1515                 updatefn   = None, 
    1616                 yieldtime  = 0.01, 
    17                  worktime   = 0.01 
    18                  ): 
     17                 worktime   = 0.01, 
     18                 ftol       = None): 
    1919        CalcThread.__init__(self,completefn, 
    2020                 updatefn, 
    … …  
    2727        self.starttime = 0 
    2828        self.updatefn = updatefn 
     29        #Relative error desired in the sum of squares. 
     30        self.ftol = ftol 
    2931    
    3032    def isquit(self): 

  • sansview/perspectives/fitting/fitpage.py

    r9466f2d6 r2296316  
    4141        ## draw sizer 
    4242        self._fill_datainfo_sizer() 
     43        self.is_2D = None 
    4344        # get smear info from data 
    4445        self._get_smear_info() 
    … …  
    4849        self._set_smear(self.data) 
    4950        self.Bind(EVT_CHI2_UPDATE, self.on_complete_chisqr) 
     51        # bind key event 
     52        self.Bind(wx.EVT_RIGHT_DOWN, self.on_right_down) 
    5053        self._set_bookmark_flag(False) 
    5154        self._set_save_flag(False) 
    … …  
    8285            self.Layout() 
    8386            return 
    84         for item in self.parameters: 
    85             if self.engine_type =="scipy" : 
    86                 item[5].SetValue("") 
    87                 item[5].Hide() 
    88                 item[6].SetValue("") 
    89                 item[6].Hide() 
    90                 self.text2_min.Hide() 
    91                 self.text2_max.Hide() 
    92  
    93             else: 
    94                 item[5].Show(True) 
    95                 item[6].Show(True) 
    96                 self.text2_min.Show(True) 
    97                 self.text2_max.Show(True) 
    98         for item in self.fittable_param: 
    99             if item[5]!=None and item[6]!=None and not \ 
    100                 item in self.orientation_params_disp: 
    101                 if self.engine_type =="scipy" and \ 
    102                     not item in self.orientation_params: 
    103                     item[5].SetValue("") 
    104                     item[5].Hide() 
    105                     item[6].SetValue("") 
    106                     item[6].Hide() 
    107                     self.text2_min.Hide() 
    108                     self.text2_max.Hide() 
    109                     self.text_disp_min.Hide() 
    110                     self.text_disp_max.Hide() 
    111                 else: 
    112                     item[5].Show(True) 
    113                     item[6].Show(True) 
    114                     self.text2_min.Show(True) 
    115                     self.text2_max.Show(True) 
    116                     self.text_disp_min.Show(True) 
    117                     self.text_disp_max.Show(True) 
    118              
    119         for item in self.orientation_params: 
    120             if item[5]!=None and item[6]!=None: 
    121                 if self.engine_type =="scipy" or \ 
    122                 self.data.__class__.__name__ !="Data2D": 
    123                     item[5].SetValue("") 
    124                     item[5].Hide() 
    125                     item[6].SetValue("") 
    126                     item[6].Hide() 
    127                 else: 
    128                     item[5].Show(True) 
    129                     item[6].Show(True) 
    130                      
    131         for item in self.orientation_params_disp:          
    132             if item[5]!=None and item[6]!=None: 
    133                 if self.engine_type =="scipy" or \ 
    134                     self.data.__class__.__name__ !="Data2D": 
    135                     item[5].SetValue("") 
    136                     item[5].Hide() 
    137                     item[6].SetValue("") 
    138                     item[6].Hide() 
    139                 else: 
    140                     item[5].Show(True) 
    141                     item[6].Show(True) 
    14287        self.Layout() 
    14388        self.Refresh() 
    … …  
    163108        smear_message_new_ssmear  =  "Please enter only the value of interest to customize smearing..." 
    164109        smear_message_new_psmear  =  "Please enter both; the dQ will be generated by interpolation..." 
    165         smear_message_2d_x_title = "<dQx>[1/A]:" 
    166         smear_message_2d_y_title = "<dQy>[1/A]:" 
     110        smear_message_2d_x_title = "<dQp>[1/A]:" 
     111        smear_message_2d_y_title = "<dQs>[1/A]:"         
    167112        smear_message_pinhole_min_title = "dQ_low[1/A]:" 
    168113        smear_message_pinhole_max_title = "dQ_high[1/A]:" 
    … …  
    253198        self.Npts_total  =  BGTextCtrl(self, -1, "-", size=(75,20), style=0) 
    254199        self.Npts_total.SetToolTipString(" Total Npts : total number of data points") 
     200        # Update and Draw button 
     201        self.draw_button = wx.Button(self,wx.NewId(),'Compute', size=(88,24)) 
     202        self.draw_button.Bind(wx.EVT_BUTTON, self._onDraw,id= self.draw_button.GetId()) 
     203        self.draw_button.SetToolTipString("Compute and Draw.") 
     204         
    255205        box_description_1= wx.StaticText(self, -1,'    Chi2/Npts') 
    256206        box_description_2= wx.StaticText(self, -1,'Fitted Npts') 
    257207        box_description_3= wx.StaticText(self, -1,'Data Npts') 
    258         box_description_4= wx.StaticText(self, -1,' ') 
     208        #box_description_4= wx.StaticText(self, -1,' ') 
    259209         
    260210         
    … …  
    262212        sizer_fit.Add(box_description_2,0,0) 
    263213        sizer_fit.Add(box_description_3,0,0)        
    264         sizer_fit.Add(box_description_4,0,0) 
     214        sizer_fit.Add(self.draw_button,0,0) 
    265215        sizer_fit.Add(self.tcChi,0,0) 
    266216        sizer_fit.Add(self.Npts_fit ,0,0) 
    … …  
    281231        self.smear_message_new_p = wx.StaticText(self, -1, smear_message_new_psmear  , style=wx.ALIGN_LEFT) 
    282232        self.smear_description_2d_x     =  wx.StaticText(self, -1, smear_message_2d_x_title  , style=wx.ALIGN_LEFT) 
     233        self.smear_description_2d_x.SetToolTipString("  dQp(parallel) in q_r direction.") 
    283234        self.smear_description_2d_y     =  wx.StaticText(self, -1, smear_message_2d_y_title  , style=wx.ALIGN_LEFT) 
     235        self.smear_description_2d_y.SetToolTipString(" dQs(perpendicular) in q_phi direction.") 
    284236        self.smear_description_pin_min     =  wx.StaticText(self, -1, smear_message_pinhole_min_title  , style=wx.ALIGN_LEFT) 
    285237        self.smear_description_pin_max     =  wx.StaticText(self, -1, smear_message_pinhole_max_title  , style=wx.ALIGN_LEFT) 
    … …  
    570522        sizer.Layout() 
    571523         
    572     def _set_sizer_dispersion(self, dispersity): 
     524    def _set_sizer_dispersion(self): 
    573525        """ 
    574526        draw sizer with gaussian dispersity parameters 
    … …  
    588540        self._reset_dispersity() 
    589541         
    590         # Create the dispersion objects 
    591         for item in self.model.dispersion.keys(): 
    592             #disp_model =  GaussianDispersion() 
    593             disp_model = dispersity() 
    594             self._disp_obj_dict[item] = disp_model 
    595             self.model.set_dispersion(item, disp_model) 
    596             self.state._disp_obj_dict[item]= disp_model 
    597  
    598  
    599         ix=0 
    600         iy=1 
     542        ## fill a sizer with the combobox to select dispersion type 
     543        #sizer_select_dispers = wx.BoxSizer(wx.HORIZONTAL)   
     544        model_disp = wx.StaticText(self, -1, 'Function') 
     545             
     546        import sans.models.dispersion_models  
     547        self.polydisp= sans.models.dispersion_models.models 
     548 
     549        ix = 0 
     550        iy = 0 
    601551        disp = wx.StaticText(self, -1, ' ') 
    602552        self.sizer4_4.Add(disp,( iy, ix),(1,1),  
    603553                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE, 15) 
    604554        ix += 1  
    605         values = wx.StaticText(self, -1, 'PD[ratio] ') 
     555        values = wx.StaticText(self, -1, 'PD[ratio]') 
    606556        polytext = "Polydispersity (= STD/mean); " 
    607557        polytext +=  "the standard deviation over the mean value." 
    … …  
    614564        self.sizer4_4.Add( self.text_disp_1,(iy, ix),(1,1),\ 
    615565                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)  
    616         self.text_disp_1.Hide() 
    617566         
    618567         
    … …  
    621570        self.sizer4_4.Add(self.text_disp_min,(iy, ix),(1,1),\ 
    622571                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)  
    623         self.text_disp_min.Hide() 
     572 
    624573        ix +=1  
    625574        self.text_disp_max = wx.StaticText(self, -1, 'Max') 
    … …  
    635584        self.sizer4_4.Add(npts,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    636585        ix += 1  
    637         nsigmas = wx.StaticText(self, -1, 'Nsigmas') 
     586        nsigmas = wx.StaticText(self, -1, 'Nsigs') 
    638587        nsigmas.SetToolTipString("   Number of sigmas between which the range\n\ 
    639588         of the distribution function will be used for weighting. \n\ 
    … …  
    642591        self.sizer4_4.Add(nsigmas,( iy, ix),(1,1), wx.EXPAND|wx.ADJUST_MINSIZE, 
    643592                           0) 
     593        ix +=1  
     594        self.sizer4_4.Add(model_disp,(iy, ix),(1,1),\ 
     595                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)  
    644596         
    645597        if self.engine_type=="park": 
    … …  
    664616                        ix = 0 
    665617                        cb = wx.CheckBox(self, -1, name0, (10, 10)) 
    666                         cb.SetToolTipString("Check for fitting") 
     618                        cb.SetToolTipString("Check mark to fit") 
    667619                        wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param) 
    668620                        self.sizer4_4.Add( cb,( iy, ix),(1,1),   
    669621                                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,  
    670                                            15) 
     622                                           5) 
    671623                        ix = 1 
    672624                        value= self.model.getParam(name1) 
    673                         ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH,20) 
     625                        ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.3,20) 
    674626                                                  ,style=wx.TE_PROCESS_ENTER) 
    675627                        ctl1.SetLabel('PD[ratio]') 
    … …  
    678630                        poly_text += " from the mean value." 
    679631                        ctl1.SetToolTipString(poly_text) 
    680                         ctl1.SetValue(str (format_number(value))) 
     632                        ctl1.SetValue(str (format_number(value, True))) 
    681633                        self.sizer4_4.Add(ctl1, (iy,ix),(1,1),wx.EXPAND) 
    682634                        ## text to show error sign 
    … …  
    688640 
    689641                        ix = 3 
    690                         ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20),  
     642                        ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/1.3,20),  
    691643                                           style=0) 
    692644                   
    … …  
    703655                        self.sizer4_4.Add(ctl3, (iy,ix),(1,1),  
    704656                                          wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    705                         ctl3.Hide() 
     657                        
    706658                 
    707659                        ix = 5 
    … …  
    713665                                          wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    714666 
    715                         ctl4.Hide() 
    716667                         
    717668                        if self.engine_type=="park": 
    718669                            ctl3.Show(True) 
    719670                            ctl4.Show(True) 
    720                                            
    721                         self.fittable_param.append([cb,name1,ctl1,text2, 
    722                                                     ctl2, ctl3, ctl4,None])                     
    723                      
     671                                                               
    724672                    elif p=="npts": 
    725673                            ix = 6 
    726674                            value= self.model.getParam(name2) 
    727675                            Tctl = self.ModelTextCtrl(self, -1,  
    728                                                       size=(_BOX_WIDTH/2,20), 
     676                                                       size=(_BOX_WIDTH/2.2,20), 
    729677                                                style=wx.TE_PROCESS_ENTER) 
    730678                             
    … …  
    738686                            value= self.model.getParam(name3) 
    739687                            Tct2 = self.ModelTextCtrl(self, -1,  
    740                                                       size=(_BOX_WIDTH/2,20), 
     688                                                      size=(_BOX_WIDTH/2.2,20), 
    741689                                                style=wx.TE_PROCESS_ENTER) 
    742690                             
    … …  
    744692                            self.sizer4_4.Add(Tct2, (iy,ix),(1,1), 
    745693                                               wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    746                             ix +=1 
    747                             self.sizer4_4.Add((20,20), (iy,ix),(1,1), 
    748                                                wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
     694                            #ix +=1 
     695                            #self.sizer4_4.Add((20,20), (iy,ix),(1,1), 
     696                            #                   wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    749697                             
    750                             self.fixed_param.append([None,name3, Tct2 
    751                                                      ,None,None,None,  
    752                                                      None,None]) 
    753                              
     698                            self.fixed_param.append([None, name3, Tct2, 
     699                                                     None, None, None,  
     700                                                     None, None]) 
     701 
     702 
     703                ix = 8       
     704                disp_box = wx.ComboBox(self, -1,size=(65,-1), 
     705                                style=wx.CB_READONLY, name = '%s'% name1) 
     706                for key, value in self.polydisp.iteritems(): 
     707                    name_disp = str(key) 
     708                    disp_box.Append(name_disp,value) 
     709                    disp_box.SetStringSelection("gaussian")  
     710                wx.EVT_COMBOBOX(disp_box,-1, self._on_disp_func)       
     711                self.sizer4_4.Add(disp_box,(iy,ix),(1,1), wx.EXPAND) 
     712                self.fittable_param.append([cb,name1,ctl1,text2, 
     713                                                    ctl2, ctl3, ctl4, disp_box])                      
     714                            
    754715        ix =0 
    755716        iy +=1  
    … …  
    776737                        ix = 0 
    777738                        cb = wx.CheckBox(self, -1, name0, (10, 10)) 
    778                         cb.SetToolTipString("Check for fitting") 
     739                        cb.SetToolTipString("Check mark to fit") 
    779740                        wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param) 
    780741                        self.sizer4_4.Add( cb,( iy, ix),(1,1),   
    781742                                           wx.LEFT|wx.EXPAND|wx.ADJUST_MINSIZE,  
    782                                            15) 
     743                                           5) 
    783744                        if self.data.__class__.__name__ =="Data2D": 
    784745                            cb.Show(True) 
    … …  
    787748                        ix = 1 
    788749                        value= self.model.getParam(name1) 
    789                         ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH, 
     750                        ctl1 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.3, 
    790751                                        20),style=wx.TE_PROCESS_ENTER) 
    791752                        poly_tip = "Absolute Sigma for %s." % item 
    792753                        ctl1.SetToolTipString(poly_tip) 
    793                         ctl1.SetValue(str (format_number(value))) 
     754                        ctl1.SetValue(str (format_number(value, True))) 
    794755                        if self.data.__class__.__name__ =="Data2D": 
    795756                            if first_orient: 
    … …  
    817778 
    818779                        ix = 3 
    819                         ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20),  
     780                        ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/1.3,20),  
    820781                                           style=0) 
    821782                     
    … …  
    842803                                          wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    843804                        ctl4.Hide() 
    844                         #if self.data.__class__.__name__ =="Data2D": 
    845                             #ctl4.Enable(True) 
    846                         #elif ctl4.Shown(): 
    847                             #ctl4.Hide() 
    848805                         
    849                         if self.engine_type=="park" and \ 
    850                                     self.data.__class__.__name__ =="Data2D": 
     806                        if self.data.__class__.__name__ =="Data2D": 
    851807                            ctl3.Show(True) 
    852808                            ctl4.Show(True)  
    853                              
    854                              
    855                              
    856                              
    857                         self.fittable_param.append([cb,name1,ctl1,text2, 
    858                                                     ctl2, ctl3, ctl4,None]) 
    859                         self.orientation_params_disp.append([cb,name1,ctl1, 
    860                                                   text2, ctl2, ctl3, ctl4,None]) 
     809                              
    861810                    elif p=="npts": 
    862811                            ix = 6 
    863812                            value= self.model.getParam(name2) 
    864813                            Tctl = self.ModelTextCtrl(self, -1,  
    865                                                       size=(_BOX_WIDTH/2,20), 
     814                                                     size=(_BOX_WIDTH/2.2, 20), 
    866815                                                style=wx.TE_PROCESS_ENTER) 
    867816                             
    … …  
    882831                            value= self.model.getParam(name3) 
    883832                            Tct2 = self.ModelTextCtrl(self, -1,  
    884                                                       size=(_BOX_WIDTH/2,20), 
     833                                                      size=(_BOX_WIDTH/2.2,20), 
    885834                                                style=wx.TE_PROCESS_ENTER) 
    886835                             
    … …  
    892841                            self.sizer4_4.Add(Tct2, (iy,ix),(1,1), 
    893842                                               wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    894                             ix +=1 
     843 
    895844 
    896845                            self.fixed_param.append([None,name3, Tct2 
    … …  
    900849                                            Tct2 ,None,None, None, None,None]) 
    901850         
     851 
     852                ix = 8       
     853                disp_box = wx.ComboBox(self, -1,size=(65,-1), 
     854                                style=wx.CB_READONLY, name = '%s'% name1) 
     855                for key, value in self.polydisp.iteritems(): 
     856                    name_disp = str(key) 
     857                    disp_box.Append(name_disp,value) 
     858                    disp_box.SetStringSelection("gaussian")  
     859                wx.EVT_COMBOBOX(disp_box,-1, self._on_disp_func)       
     860                self.sizer4_4.Add(disp_box,(iy,ix),(1,1), wx.EXPAND) 
     861                self.fittable_param.append([cb,name1,ctl1,text2, 
     862                                            ctl2, ctl3, ctl4, disp_box]) 
     863                self.orientation_params_disp.append([cb,name1,ctl1, 
     864                                            text2, ctl2, ctl3, ctl4, disp_box]) 
     865                        
     866                if self.data.__class__.__name__ =="Data2D": 
     867                    disp_box.Show(True) 
     868                else: 
     869                    disp_box.Hide() 
     870         
     871 
    902872        self.state.disp_cb_dict = copy.deepcopy(self.disp_cb_dict)   
    903873           
    … …  
    920890        self.Layout() 
    921891 
     892     
     893    def _onDraw(self, event): 
     894        """ 
     895        Update and Draw the model 
     896        """  
     897        if self.model ==None: 
     898            msg="Please select a Model first..." 
     899            wx.MessageBox(msg, 'Info') 
     900            wx.PostEvent(self.manager.parent, StatusEvent(status=\ 
     901                            "Draw model: %s"%msg)) 
     902            return 
     903        flag = self._update_paramv_on_fit()          
     904        self._onparamEnter_helper() 
     905        if not flag: 
     906            msg= "The parameters are invalid" 
     907            wx.PostEvent(self.parent.parent, StatusEvent(status= msg )) 
     908            return  
     909         
     910 
    922911    def _onFit(self, event):      
    923912        """ 
    … …  
    934923            wx.MessageBox(msg, 'Info') 
    935924            wx.PostEvent(self._manager.parent, StatusEvent(status=\ 
    936                             "Fit: %s" % msg)) 
     925                            "Fit: %s"%msg, type="stop")) 
    937926            return 
    938927 
    … …  
    941930        if not flag: 
    942931            msg= "Fitting range or parameters are invalid" 
    943             wx.PostEvent(self.parent.parent, StatusEvent(status= msg )) 
     932            wx.PostEvent(self.parent.parent, StatusEvent(status= msg,  
     933                                                         type="stop")) 
    944934            return  
    945935         
    946936        if len(self.param_toFit) <= 0: 
    947937            msg= "Select at least one parameter to fit" 
    948             wx.PostEvent(self.parent.parent, StatusEvent(status= msg )) 
     938            wx.PostEvent(self.parent.parent, StatusEvent(status= msg,  
     939                                                         type="stop" )) 
    949940            return  
    950941       
    … …  
    12271218                    self.set_npts2fit()  
    12281219            else: 
    1229                 if self.data is not None: 
    1230                      
    1231                     index_data = ((self.qmin_x <= self.data.x)& \ 
    1232                                   (self.data.x <= self.qmax_x)) 
    1233                     self.Npts_fit.SetValue(str(len(self.data.x[index_data]))) 
    1234  
     1220                index_data = ((self.qmin_x <= self.data.x)& \ 
     1221                              (self.data.x <= self.qmax_x)) 
     1222                self.Npts_fit.SetValue(str(len(self.data.x[index_data]))) 
    12351223            
    12361224        else: 
    … …  
    16981686            raise ValueError,"missing parameter to fit"     
    16991687       
    1700     def onsetValues(self,chisqr,p_name, out,cov): 
     1688    def onsetValues(self, chisqr, p_name, out, cov): 
    17011689        """ 
    17021690        Build the panel from the fit result 
    … …  
    17181706         
    17191707        #Check if chi2 is finite 
    1720         if chisqr != None or numpy.isfinite(chisqr): 
     1708        if chisqr != None and numpy.isfinite(chisqr): 
    17211709        #format chi2   
    17221710            if self.engine_type == "park":   
    … …  
    17241712                if npt_fit > 0: 
    17251713                    chisqr =chisqr/npt_fit     
    1726             chi2 = format_number(chisqr)     
     1714            chi2 = format_number(chisqr, True)     
    17271715            self.tcChi.SetValue(chi2)     
    17281716            self.tcChi.Refresh()     
    … …  
    17351723       
    17361724        try: 
    1737             n = self.disp_box.GetCurrentSelection() 
    1738             dispersity= self.disp_box.GetClientData(n) 
    1739             if dispersity !=None and self.enable_disp.GetValue(): 
    1740                 name= dispersity.__name__ 
    1741                 if name == "GaussianDispersion": 
    1742                     if hasattr(self,"text_disp_1" ): 
    1743                         if self.text_disp_1 !=None: 
    1744                             self.text_disp_1.Hide() 
     1725            if self.enable_disp.GetValue(): 
     1726                if hasattr(self,"text_disp_1" ): 
     1727                    if self.text_disp_1 != None: 
     1728                        self.text_disp_1.Hide() 
    17451729        except: 
    17461730            dispersty = None 
    … …  
    17481732        #set the panel when fit result are float not list 
    17491733        if out.__class__== numpy.float64: 
    1750             self.param_toFit[0][2].SetValue(format_number(out)) 
     1734            self.param_toFit[0][2].SetValue(format_number(out, True)) 
    17511735             
    17521736            if self.param_toFit[0][4].IsShown: 
    … …  
    17551739                self.text2_3.Show(True) 
    17561740                try: 
    1757                     if dispersity !=None: 
    1758                         name= dispersity.__name__ 
    1759                         if name == "GaussianDispersion" and \ 
    1760                         self.enable_disp.GetValue(): 
    1761                             if hasattr(self,"text_disp_1" ): 
    1762                                 if self.text_disp_1 !=None: 
    1763                                     self.text_disp_1.Show(True) 
     1741                    if self.enable_disp.GetValue(): 
     1742                        if hasattr(self,"text_disp_1" ): 
     1743                            if self.text_disp_1 !=None: 
     1744                                self.text_disp_1.Show(True) 
    17641745                except: 
    17651746                    pass 
    … …  
    17711752                    self.param_toFit[0][3].Show(True)                
    17721753                    self.param_toFit[0][4].Show(True) 
    1773                     self.param_toFit[0][4].SetValue(format_number(cov[0])) 
     1754                    self.param_toFit[0][4].SetValue(format_number(cov[0], True)) 
    17741755                    has_error = True 
    17751756        else: 
    … …  
    17881769                            break         
    17891770                    if len(out)<=len(self.param_toFit) and out[ind] !=None:    
    1790                         val_out = format_number(out[ind])                   
     1771                        val_out = format_number(out[ind], True)                   
    17911772                        item[2].SetValue(val_out) 
    17921773 
    … …  
    17951776                        try: 
    17961777                            if dispersity !=None: 
    1797                                 name= dispersity.__name__ 
    1798                                 if name == "GaussianDispersion" and \ 
    1799                                                 self.enable_disp.GetValue(): 
     1778                                if self.enable_disp.GetValue(): 
    18001779                                    if hasattr(self,"text_disp_1" ): 
    18011780                                        if self.text_disp_1!=None: 
    … …  
    18071786                        if cov[ind]!=None : 
    18081787                            if numpy.isfinite(float(cov[ind])): 
    1809                                 val_err = format_number(cov[ind]) 
     1788                                val_err = format_number(cov[ind], True) 
    18101789                                item[3].Show(True) 
    18111790                                item[4].Show(True) 
    … …  
    18211800        ## save current state   
    18221801        self.save_current_state()           
    1823         #plot model 
    1824         self._draw_model()    
    1825         self._lay_out()       
     1802        #plot model ( when drawing, do not update chisqr value again) 
     1803        self._draw_model(update_chisqr=False)    
     1804        self._lay_out()    
     1805        self.Refresh()     
    18261806        #PostStatusEvent      
    18271807        msg = "Fit completed! " 
    … …  
    22672247            else: 
    22682248                output = event.output 
    2269             self.tcChi.SetValue(str(format_number(output))) 
     2249            self.tcChi.SetValue(str(format_number(output, True))) 
    22702250 
    22712251            self.state.tcChi = self.tcChi.GetValue() 
    … …  
    22962276                        item[0].SetValue(True) 
    22972277                        self.param_toFit.append(item ) 
     2278                        try: 
     2279                            if len(self.values[item[1]]) > 0: 
     2280                                item[0].SetValue(False) 
     2281                        except: 
     2282                            pass 
     2283 
    22982284                    else: 
    22992285                        ## for 1D all parameters except orientation 
    … …  
    23012287                            item[0].SetValue(True) 
    23022288                            self.param_toFit.append(item ) 
     2289                            try: 
     2290                                if len(self.values[item[1]]) > 0: 
     2291                                    item[0].SetValue(False) 
     2292                            except: 
     2293                                pass 
     2294 
    23032295            else: 
    23042296                for item in self.parameters: 
    … …  
    24762468        sizer.Add(self.text2_min,(iy, ix),(1,1),\ 
    24772469                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)  
    2478         self.text2_min.Hide() 
     2470        #self.text2_min.Hide() 
    24792471        ix +=1  
    24802472        self.text2_max = wx.StaticText(self, -1, 'Max') 
    24812473        sizer.Add(self.text2_max,(iy, ix),(1,1),\ 
    24822474                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)  
    2483         self.text2_max.Hide() 
     2475        #self.text2_max.Hide() 
    24842476        ix += 1 
    24852477        self.text2_4 = wx.StaticText(self, -1, '[Units]') 
    … …  
    24872479                            wx.EXPAND|wx.ADJUST_MINSIZE, 0)  
    24882480        self.text2_4.Hide() 
    2489         if self.engine_type=="park": 
    2490             self.text2_max.Show(True) 
    2491             self.text2_min.Show(True) 
    24922481         
    24932482        for item in keys: 
    … …  
    25242513                                style=wx.TE_PROCESS_ENTER, name ='%s'% item) 
    25252514                        fun_box.SetToolTipString("Hit 'Enter' after typing.") 
    2526                         fun_box.SetValue(format_number(value)) 
     2515                        fun_box.SetValue(format_number(value, True)) 
    25272516                    sizer.Add(fun_box, (iy,ix),(1,1), wx.EXPAND) 
    25282517                    self.str_parameters.append([None,item, fun_box, 
    2529                                                 None,None,None,None,None]) 
     2518                                                None, None, None,  
     2519                                                None, None]) 
    25302520 
    25312521                     
    … …  
    25332523                    ## add parameters name with checkbox for selecting to fit 
    25342524                    cb = wx.CheckBox(self, -1, item )               
    2535                     cb.SetToolTipString(" Check for fitting.") 
     2525                    cb.SetToolTipString(" Check mark to fit.") 
    25362526                    #cb.SetValue(True) 
    25372527                    wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param) 
    … …  
    25462536                                        style=wx.TE_PROCESS_ENTER) 
    25472537                    ctl1.SetToolTipString("Hit 'Enter' after typing.") 
    2548                     ctl1.SetValue(format_number(value)) 
     2538                    ctl1.SetValue(format_number(value, True)) 
    25492539                    sizer.Add(ctl1, (iy,ix),(1,1), wx.EXPAND) 
    25502540                    ## text to show error sign 
    … …  
    25552545                    text2.Hide()  
    25562546                    ix += 1 
    2557                     ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=0) 
     2547                    ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/1.2,20), style=0) 
    25582548                    sizer.Add(ctl2, (iy,ix),(1,1),  
    25592549                              wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    … …  
    25612551                     
    25622552                    ix += 1 
    2563                     ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), 
     2553                    ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.9,20), 
    25642554                                               style=wx.TE_PROCESS_ENTER, 
    25652555                                text_enter_callback = self._onparamRangeEnter) 
    … …  
    25672557                    sizer.Add(ctl3, (iy,ix),(1,1),  
    25682558                              wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    2569                     ctl3.Hide() 
    25702559             
    25712560                    ix += 1 
    2572                     ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), 
     2561                    ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.9,20), 
    25732562                                               style=wx.TE_PROCESS_ENTER, 
    25742563                                text_enter_callback = self._onparamRangeEnter) 
    25752564                    sizer.Add(ctl4, (iy,ix),(1,1),  
    2576                               wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    2577            
    2578                     ctl4.Hide() 
     2565                              wx.EXPAND|wx.FIXED_MINSIZE, 0) 
    25792566     
    2580                     if self.engine_type=="park": 
    2581                         ctl3.Show(True) 
    2582                         ctl4.Show(True) 
    25832567                    ix +=1 
    25842568                    # Units 
    … …  
    26322616                    cb = wx.CheckBox(self, -1, item ) 
    26332617                    cb.SetValue(False) 
    2634                     cb.SetToolTipString("Check for fitting") 
     2618                    cb.SetToolTipString("Check mark to fit") 
    26352619                    wx.EVT_CHECKBOX(self, cb.GetId(), self.select_param) 
    26362620                    if self.data.__class__.__name__ =="Data2D": 
    … …  
    26472631                                        style=wx.TE_PROCESS_ENTER) 
    26482632                    ctl1.SetToolTipString("Hit 'Enter' after typing.") 
    2649                     ctl1.SetValue(format_number(value)) 
     2633                    ctl1.SetValue(format_number(value, True)) 
    26502634                    if self.data.__class__.__name__ =="Data2D": 
    26512635                        ctl1.Show(True) 
    … …  
    26602644                    text2.Hide()  
    26612645                    ix += 1 
    2662                     ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH,20), style=0) 
     2646                    ctl2 = wx.TextCtrl(self, -1, size=(_BOX_WIDTH/1.2,20), style=0) 
    26632647                    sizer.Add(ctl2, (iy,ix),(1,1),  
    26642648                              wx.EXPAND|wx.ADJUST_MINSIZE, 0) 
    … …  
    26672651                     
    26682652                    ix += 1 
    2669                     ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20),  
     2653                    ctl3 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.8,20),  
    26702654                                              style=wx.TE_PROCESS_ENTER, 
    26712655                                text_enter_callback = self._onparamRangeEnter) 
    … …  
    26762660                  
    26772661                    ix += 1 
    2678                     ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/2,20), 
     2662                    ctl4 = self.ModelTextCtrl(self, -1, size=(_BOX_WIDTH/1.8,20), 
    26792663                                               style=wx.TE_PROCESS_ENTER, 
    26802664                            text_enter_callback = self._onparamRangeEnter) 
    … …  
    26842668                    ctl4.Hide() 
    26852669                     
    2686                     if self.engine_type =="park" and \ 
    2687                             self.data.__class__.__name__ =="Data2D":                       
     2670                    if self.data.__class__.__name__ =="Data2D":                       
    26882671                        ctl3.Show(True) 
    26892672                        ctl4.Show(True) 
    … …  
    27272710        self.Layout() 
    27282711        self.Refresh() 
    2729       
     2712         
     2713    def on_right_down(self, event): 
     2714        """ 
     2715        Get key stroke event 
     2716        """ 
     2717        if self.data == None: 
     2718            return 
     2719        # Figuring out key combo: Cmd for copy, Alt for paste 
     2720        if event.AltDown() and event.ShiftDown(): 
     2721            self._show_ftol_dialog() 
     2722            flag = True 
     2723        else: 
     2724            flag = False 
     2725        # make event free 
     2726        event.Skip() 
     2727        # messages depending on the flag 
     2728        if not flag: 
     2729            msg = " Could not open ftol dialog;" 
     2730            msg += " Check if the Scipy fit engine is selected in the menubar." 
     2731            infor = 'warning' 
     2732            # inform msg to wx 
     2733            wx.PostEvent( self.parent.parent,  
     2734                          StatusEvent(status= msg, info=infor)) 
     2735 
     2736 
     2737    def _show_ftol_dialog(self): 
     2738        """ 
     2739        Dialog to select ftol for Scipy 
     2740        """ 
     2741        from ftol_dialog import ChangeFtol 
     2742        panel = ChangeFtol(self) 
     2743        panel.ShowModal() 
     2744         
    27302745    def _onModel2D(self, event): 
    27312746        """ 

  • sansview/perspectives/fitting/fitpanel.py

    r9466f2d6 r2296316  
    6161        #add default pages 
    6262        self.add_default_pages() 
     63 
    6364     
    6465    def _on_engine_change(self, name='scipy'): 
    … …  
    140141        Add default pages such as a hint page and an empty fit page 
    141142        """ 
     143        pass 
    142144        #add default page 
    143         from hint_fitpage import HintFitPage 
    144         self.hint_page = HintFitPage(self)  
    145         self.AddPage(self.hint_page,"Hint") 
    146         self.hint_page.set_manager(self._manager) 
     145        #from hint_fitpage import HintFitPage 
     146        #self.hint_page = HintFitPage(self)  
     147        #self.AddPage(self.hint_page,"Hint") 
     148        #self.hint_page.set_manager(self._manager) 
    147149   
    148150    def close_all(self): 

  • sansview/perspectives/fitting/fitting.py

    r9466f2d6 r2296316  
    6969        self.calc_1D = None 
    7070        self.fit_thread_list = {} 
     71        self.residuals = None 
    7172        self.fit_panel = None 
    7273        # Start with a good default 
    … …  
    7475        # the type of optimizer selected, park or scipy 
    7576        self.fitter  = None 
     77        self.fit_panel = None 
    7678        #let fit ready 
    7779        self.fitproblem_count = None 
    … …  
    8284        ## Fit engine 
    8385        self._fit_engine = 'scipy' 
     86        ## Relative error desired in the sum of squares (float); scipy only 
     87        self.ftol=1.49012e-08 
    8488        #List of selected data 
    8589        self.selected_data_list = [] 
    … …  
    132136        id1 = wx.NewId() 
    133137        simul_help = "Simultaneous Fit" 
    134         self.menu1.Append(id1, '&Simultaneous Page',simul_help) 
     138        self.menu1.Append(id1, '&Simultaneous Fit',simul_help) 
    135139        wx.EVT_MENU(owner, id1, self.on_add_sim_page) 
    136140         
    … …  
    143147    
    144148        #create  menubar items 
    145         return [(self.menu1, "Fitting")] 
     149        return [(self.menu1, "FitEngine")] 
    146150                
    147151    def on_add_sim_page(self, event): 
    … …  
    445449                param_name=param_names[1]                     
    446450            return model_name,param_name 
    447          
     451    
     452    def set_ftol(self, ftol=None): 
     453        """ 
     454        Set ftol: Relative error desired in the sum of chi squares.   
     455        """ 
     456        # check if it is flaot 
     457        try: 
     458            f_tol = float(ftol) 
     459        except: 
     460            # default 
     461            f_tol = 1.49012e-08 
     462             
     463        self.ftol = f_tol 
     464               
    448465    def stop_fit(self, uid): 
    449466        """ 
    … …  
    492509                   state=None, 
    493510                   toggle_mode_on=False, 
    494                    qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, qstep=DEFAULT_NPTS): 
     511                   qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX,  
     512                   qstep=DEFAULT_NPTS, 
     513                   update_chisqr=True): 
    495514        """ 
    496515        Draw model. 
    … …  
    505524        :param qmax:  Range's maximum value to draw model 
    506525        :param qstep: number of step to divide the x and y-axis 
     526        :param update_chisqr: update chisqr [bool] 
    507527              
    508528        """ 
    … …  
    519539                               toggle_mode_on=toggle_mode_on, 
    520540                               state=state, 
    521                                qstep=qstep) 
     541                               qstep=qstep, 
     542                               update_chisqr=update_chisqr) 
    522543        else:      
    523544            ## draw model 2D with no initial data 
    … …  
    531552                                state=state, 
    532553                                toggle_mode_on=toggle_mode_on, 
    533                                 qstep=qstep) 
     554                                qstep=qstep, 
     555                                update_chisqr=update_chisqr) 
    534556             
    535557    def onFit(self): 
    … …  
    598620            calc_fit = FitThread(handler = handler, 
    599621                                    fn=fitter, 
    600                                    pars=pars, 
    601                                    page_id=list_page_id, 
    602                                    completefn=self._single_fit_completed) 
     622                                    pars=pars, 
     623                                    page_id=list_page_id, 
     624                                    completefn=self._single_fit_completed, 
     625                                    ftol=self.ftol) 
    603626        else: 
    604627            current_page_id = self.sim_page.uid 
    … …  
    607630                                    fn=fitter, 
    608631                                    page_id=list_page_id, 
    609                                    completefn= self._simul_fit_completed) 
     632                                    updatefn=handler.update_fit, 
     633                                    ftol=self.ftol) 
    610634        self.fit_thread_list[current_page_id] = calc_fit 
    611635        calc_fit.queue() 
    … …  
    851875        try: 
    852876            if result == None: 
    853                 msg= "Simple Fitting Stop !!!" 
    854                 wx.PostEvent(self.parent, StatusEvent(status=msg,info="warning", 
    855                                                       type="stop")) 
     877                msg= "Single Fitting did not converge!!!" 
     878                wx.PostEvent(self.parent,  
     879                             StatusEvent(status=msg,  
     880                                         info="warning", 
     881                                         type="stop")) 
    856882                return 
    857883            if not numpy.isfinite(result.fitness) or \ 
    … …  
    860886                msg = "Single Fitting did not converge!!!" 
    861887                wx.PostEvent(self.parent,  
    862                              StatusEvent(status=msg, type="stop")) 
     888                             StatusEvent(status=msg,  
     889                                         info="warning", 
     890                                         type="stop")) 
    863891                return 
    864892            for uid in page_id: 
    … …  
    875903                                  param_name, result.pvec,result.stderr) 
    876904                cpage._on_fit_complete() 
    877             
     905 
     906        except ValueError: 
     907            msg = "Single Fitting did not converge!!!" 
     908            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
     909                                                  type="stop")) 
     910            return    
    878911        except: 
    879912            raise 
    … …  
    899932            msg = ""  
    900933            if result == None: 
    901                 msg = "Complex Fitting Stop !!!" 
     934                msg= "Complex Fitting did not converge!!!" 
    902935                wx.PostEvent(self.parent, StatusEvent(status=msg, 
    903936                                                      type="stop")) 
    … …  
    933966                                  small_out,small_cov) 
    934967                cpage._on_fit_complete() 
     968                 
     969        except Exception: 
     970            msg = "Complex Fitting did not converge!!!" 
     971            wx.PostEvent(self.parent, StatusEvent(status=msg, info="error", 
     972                                                  type="stop")) 
     973            return 
     974 
    935975        except: 
    936976            msg = "Simultaneous Fit completed" 
    … …  
    11441184   
    11451185    def _complete1D(self, x,y, page_id, elapsed,index,model, 
    1146                     toggle_mode_on=False,state=None, data=None): 
     1186                    toggle_mode_on=False,state=None,  
     1187                    data=None, update_chisqr=True): 
    11471188        """ 
    11481189        Complete plotting 1D data 
    … …  
    12021243            wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, 
    12031244                                            title= str(title))) 
    1204              
    1205             wx.PostEvent(current_pg, 
    1206                 Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
     1245            if update_chisqr: 
     1246                wx.PostEvent(current_pg, 
     1247                             Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
    12071248                                                        page_id=page_id, 
    12081249                                                        index=index))) 
     1250            else: 
     1251                self._plot_residuals(page_id, data, index) 
     1252 
    12091253            msg = "Plot 1D  complete !" 
    12101254            wx.PostEvent( self.parent, StatusEvent(status=msg, type="stop" )) 
     1255            #self.current_pg.state.theory_data = deepcopy(self.theory_data) 
    12111256        except: 
    12121257            raise 
    … …  
    12241269   
    12251270    def _complete2D(self, image, data, model, page_id,  elapsed, index, qmin, 
    1226                      qmax, toggle_mode_on=False,state=None,qstep=DEFAULT_NPTS): 
     1271                     qmax, toggle_mode_on=False,state=None,qstep=DEFAULT_NPTS,  
     1272                     update_chisqr=True): 
    12271273        """ 
    12281274        Complete get the result of modelthread and create model 2D 
    … …  
    12841330                                               title=title)) 
    12851331        # Chisqr in fitpage 
    1286         wx.PostEvent(current_pg, 
    1287             Chi2UpdateEvent(output=self._cal_chisqr(data=data, 
     1332        if update_chisqr: 
     1333            wx.PostEvent(current_pg, 
     1334                         Chi2UpdateEvent(output=\ 
     1335                                    self._cal_chisqr(data=data, 
    12881336                                                     page_id=page_id, 
    12891337                                                     index=index))) 
     1338        else: 
     1339            self._plot_residuals(page_id, data, index) 
    12901340        msg = "Plot 2D complete !" 
    12911341        wx.PostEvent(self.parent, StatusEvent(status=msg, type="stop")) 
    … …  
    12961346                      toggle_mode_on=False, 
    12971347                      qmin=DEFAULT_QMIN, qmax=DEFAULT_QMAX, 
    1298                        qstep=DEFAULT_NPTS): 
     1348                      qstep=DEFAULT_NPTS, 
     1349                      update_chisqr=True): 
    12991350        """ 
    13001351        draw model in 2D 
    … …  
    13461397                                    toggle_mode_on=toggle_mode_on, 
    13471398                                    state=state, 
    1348                                     completefn=self._complete2D)#, 
    1349                                     #updatefn=self._update2D) 
     1399                                    completefn=self._complete2D, 
     1400                                    #updatefn= self._update2D, 
     1401                                    update_chisqr=update_chisqr) 
     1402 
    13501403            self.calc_2D.queue() 
    13511404 
    … …  
    13601413                state=None, 
    13611414                toggle_mode_on=False, 
    1362                 qstep=DEFAULT_NPTS, enable1D=True): 
     1415                qstep=DEFAULT_NPTS, update_chisqr=True,  
     1416                enable1D=True): 
    13631417        """ 
    13641418        Draw model 1D from loaded data1D 
    … …  
    13781432                return 
    13791433            x = data.x 
    1380             if qmin == DEFAULT_QMIN : 
    1381                 qmin = min(data.x) 
    1382             if qmax == DEFAULT_QMAX: 
    1383                 qmax = max(data.x)  
     1434            if qmin == None : 
     1435                qmin == DEFAULT_QMIN 
     1436 
     1437            if qmax == None: 
     1438                qmax == DEFAULT_QMAX  
    13841439        if not enable1D: 
    13851440            return  
    … …  
    13981453                                  state=state, 
    13991454                                  toggle_mode_on=toggle_mode_on, 
    1400                                   completefn=self._complete1D)#, 
    1401                                   #updatefn=self._update1D) 
     1455                                  completefn=self._complete1D, 
     1456                                  #updatefn = self._update1D, 
     1457                                  update_chisqr=update_chisqr) 
     1458 
    14021459            self.calc_1D.queue() 
    14031460 
    … …  
    14191476         
    14201477        # Get data: data I, theory I, and data dI in order 
    1421         if data.__class__.__name__ =="Data2D": 
     1478        if data.__class__.__name__ == "Data2D": 
    14221479            if index == None:  
    14231480                index = numpy.ones(len(data.data),ntype=bool) 
    14241481            # get rid of zero error points 
    1425             index = index & (data.err_data != 0)   
     1482            index = index & (data.err_data != 0 )   
     1483            index = index & (numpy.isfinite(data.data))  
    14261484            fn = data.data[index]  
    14271485            theory_data = self.page_finder[page_id].get_theory_data() 
    … …  
    14301488        else: 
    14311489            # 1 d theory from model_thread is only in the range of index 
    1432             if index == None: 
     1490            if index == None:  
    14331491                index = numpy.ones(len(data.y), ntype=bool) 
    14341492            if data.dy == None or data.dy == []: 
    … …  
    14371495                ## Set consitently w/AbstractFitengine: 
    14381496                # But this should be corrected later. 
    1439                 dy = data.dy 
     1497                dy = deepcopy(data.dy) 
    14401498                dy[dy==0] = 1   
    14411499            fn = data.y[index]  
    … …  
    14441502            en = dy[index] 
    14451503        # residual 
    1446         res = (fn - gn)/en 
     1504        res = (fn - gn) / en 
     1505        residuals = res[numpy.isfinite(res)] 
    14471506        # get chisqr only w/finite 
    1448         val = res[numpy.isfinite(res)]*res[numpy.isfinite(res)] 
    1449         chisqr = numpy.average(val) 
     1507        chisqr = numpy.average(residuals * residuals) 
     1508         
     1509        self._plot_residuals(page_id, data, index) 
    14501510        return chisqr 
    14511511     
    1452      
     1512 
     1513         
     1514    def _plot_residuals(self, page_id, data=None, index=None):  
     1515        """ 
     1516        Plot the residuals 
     1517         
     1518        :param data: data 
     1519        :param index: index array (bool)  
     1520        : Note: this is different from the residuals in cal_chisqr() 
     1521        """ 
     1522        if data == None:  
     1523            return  
     1524         
     1525        # Get data: data I, theory I, and data dI in order 
     1526        if data.__class__.__name__ == "Data2D": 
     1527            # build residuals 
     1528            #print data 
     1529            residuals = Data2D() 
     1530            #residuals.copy_from_datainfo(data) 
     1531            # Not for trunk the line below, instead use the line above 
     1532            data.clone_without_data(len(data.data), residuals) 
     1533            residuals.data = None 
     1534            fn = data.data#[index]  
     1535            theory_data = self.page_finder[page_id].get_theory_data() 
     1536            gn = theory_data.data#[index] 
     1537            en = data.err_data#[index] 
     1538            residuals.data = (fn - gn) / en  
     1539            residuals.qx_data = data.qx_data#[index] 
     1540            residuals.qy_data = data.qy_data #[index] 
     1541            residuals.q_data = data.q_data#[index] 
     1542            residuals.err_data = numpy.ones(len(residuals.data))#[index] 
     1543            residuals.xmin = min(residuals.qx_data) 
     1544            residuals.xmax = max(residuals.qx_data) 
     1545            residuals.ymin = min(residuals.qy_data) 
     1546            residuals.ymax = max(residuals.qy_data) 
     1547            residuals.q_data = data.q_data#[index] 
     1548            residuals.mask = data.mask 
     1549            residuals.scale = 'linear' 
     1550            #print "print data",residuals 
     1551            # check the lengths 
     1552            if len(residuals.data) != len(residuals.q_data): 
     1553                return 
     1554 
     1555        else: 
     1556            # 1 d theory from model_thread is only in the range of index 
     1557            if data.dy == None or data.dy == []: 
     1558                dy = numpy.ones(len(data.y)) 
     1559            else: 
     1560                ## Set consitently w/AbstractFitengine:  
     1561                ## But this should be corrected later. 
     1562                dy = deepcopy(data.dy) 
     1563                dy[dy==0] = 1   
     1564            fn = data.y[index]  
     1565            theory_data = self.page_finder[page_id].get_theory_data() 
     1566            gn = theory_data.y 
     1567            en = dy[index] 
     1568            # build residuals 
     1569            residuals = Data1D() 
     1570            residuals.y = (fn - gn) / en 
     1571            residuals.x = data.x[index] 
     1572            residuals.dy = numpy.ones(len(residuals.y)) 
     1573            residuals.dx = None 
     1574            residuals.dxl = None 
     1575            residuals.dxw = None 
     1576            residuals.ytransform = 'y' 
     1577            # For latter scale changes  
     1578            residuals.xaxis('\\rm{Q} ', 'A^{-1}') 
     1579            residuals.yaxis('\\rm{Residuals} ', 'normalized') 
     1580             
     1581        new_plot = residuals 
     1582        if data.id == None: 
     1583            data.id = data.name 
     1584        name  = data.id 
     1585        new_plot.name = "Residuals for " + str(data.name) 
     1586        ## allow to highlight data when plotted 
     1587        new_plot.interactive = True 
     1588        ## when 2 data have the same id override the 1 st plotted 
     1589        new_plot.id = new_plot.name#name + " residuals" 
     1590        ##group_id specify on which panel to plot this data 
     1591        new_plot.group_id = new_plot.id 
     1592        #new_plot.is_data = True 
     1593        ##post data to plot 
     1594        title = new_plot.name  
     1595         
     1596        # plot data 
     1597        wx.PostEvent(self.parent, NewPlotEvent(plot=new_plot, title=title))    
     1598    
    14531599#def profile(fn, *args, **kw): 
    14541600#    import cProfile, pstats, os 

  • sansview/perspectives/fitting/model_thread.py

    re4957fb r2296316  
    2020                 completefn = None, 
    2121                 updatefn   = None, 
     22                 update_chisqr=True, 
    2223                 yieldtime  = 0.01, 
    2324                 worktime   = 0.01 
    … …  
    4041        self.smearer = smearer#(data=self.data,model=self.model) 
    4142        self.starttime = 0   
     43        self.update_chisqr = update_chisqr 
    4244         
    4345    def compute(self): 
    … …  
    130132                       qmin=self.qmin, 
    131133                       qmax=self.qmax, 
    132                        qstep=self.qstep) 
     134                       qstep=self.qstep, 
     135                       update_chisqr = self.update_chisqr ) 
    133136         
    134137 
    … …  
    146149                 state=None, 
    147150                 completefn = None, 
     151                 update_chisqr=True, 
    148152                 updatefn   = None, 
    149153                 yieldtime  = 0.01, 
    … …  
    166170        self.smearer = smearer 
    167171        self.starttime = 0 
     172        self.update_chisqr = update_chisqr 
    168173         
    169174    def compute(self): 
    … …  
    190195                      toggle_mode_on=self.toggle_mode_on, 
    191196                      elapsed=elapsed,index=index, model=self.model, 
    192                                         data=self.data) 
     197                      data=self.data,  
     198                      update_chisqr = self.update_chisqr ) 
    193199         
    194200    def results(self): 

  • sansview/perspectives/fitting/pagestate.py

    rdce84c0 r2296316  
    4747                      ["formfactorcombobox", "formfactorcombobox", "float"], 
    4848                      ["structurecombobox", "structurecombobox", "float"], 
    49                       ["disp_box", "disp_box", "float"], 
    5049                      ["enable_smearer","enable_smearer","bool"], 
    5150                      ["disable_smearer","disable_smearer","bool"], 
    … …  
    6564list_of_model_attributes = [["values", "values"], 
    6665                            ["weights", "weights"]] 
     66 
     67list_of_obj_dic =  [["disp_obj_dict", "_disp_obj_dict", "string"]] 
    6768 
    6869list_of_state_parameters = [["parameters", "parameters"] ,  
    … …  
    139140        #Data used for fitting  
    140141        self.data = data 
     142        # model data 
     143        self.theory_data = None 
     144        #Is 2D 
     145        self.is_2D = False 
     146        self.images = None 
     147         
    141148        #save additional information on data that dataloader.reader does not read 
    142149        self.is_data = None 
    … …  
    196203        if self.model is not None: 
    197204            self.disp_list = self.model.getDispParamList() 
    198         self._disp_obj_dict = {} 
     205 
    199206        self.disp_cb_dict = {} 
    200         self.values = [] 
    201         self.weights = [] 
     207        self.values = {} 
     208        self.weights = {} 
     209 
    202210                     
    203211        #contains link between a model and selected parameters to fit  
    … …  
    289297            for k , v in self.disp_cb_dict.iteritems(): 
    290298                obj.disp_cb_dict[k]= v 
    291                  
    292         obj.values = copy.deepcopy(self.values) 
    293         obj.weights = copy.deepcopy(self.weights) 
     299        if len(self.values)>0:  
     300            for k , v in self.values.iteritems():        
     301                obj.values[k] = v 
     302        if len(self.weights)>0:  
     303            for k , v in self.weights.iteritems():        
     304                obj.weights[k] = v 
    294305        obj.enable_smearer = copy.deepcopy(self.enable_smearer) 
    295306        obj.disable_smearer = copy.deepcopy(self.disable_smearer) 
    … …  
    337348        rep = "\nState name: %s\n"%self.file 
    338349        t = time.localtime(self.timestamp) 
    339         time_str = time.strftime("%b %d %H:%M", t) 
     350        time_str = time.strftime("%b %d %H;%M of %Y", t) 
    340351        rep += "State created on : %s\n"%time_str 
    341352        rep += "State form factor combobox selection: %s\n"%self.formfactorcombobox 
    … …  
    368379         
    369380        rep += "model  : %s\n\n"% str(self.model) 
    370         rep += "number parameters(self.parameters): %s\n"%len(self.parameters) 
    371         rep = self._repr_helper( list=self.parameters, rep=rep) 
    372         rep += "number str_parameters(self.str_parameters): %s\n"%len(self.str_parameters) 
    373         rep = self._repr_helper( list=self.str_parameters, rep=rep) 
    374         rep += "number orientation parameters" 
    375         rep += "(self.orientation_params): %s\n"%len(self.orientation_params) 
    376         rep = self._repr_helper( list=self.orientation_params, rep=rep) 
    377         rep += "number dispersity parameters" 
    378         rep += "(self.orientation_params_disp): %s\n"%len(self.orientation_params_disp) 
    379         rep = self._repr_helper( list=self.orientation_params_disp, rep=rep) 
     381        temp_parameters = [] 
     382        temp_fittable_param = [] 
     383        if self.data.__class__.__name__ == "Data2D": 
     384            self.is_2D = True 
     385        else: 
     386            self.is_2D = False 
     387        if self.data is not None: 
     388            if not self.is_2D: 
     389                for item in self.parameters: 
     390                    if not item in self.orientation_params: 
     391                        temp_parameters.append(item) 
     392                for item in self.fittable_param: 
     393                    if not item in self.orientation_params_disp: 
     394                        temp_fittable_param.append(item) 
     395            else: 
     396                temp_parameters = self.parameters 
     397                temp_fittable_param = self.fittable_param 
     398                 
     399            rep += "number parameters(self.parameters): %s\n"%len(temp_parameters) 
     400            rep = self._repr_helper( list=temp_parameters, rep=rep) 
     401            rep += "number str_parameters(self.str_parameters): %s\n"%len(self.str_parameters) 
     402            rep = self._repr_helper( list=self.str_parameters, rep=rep)  
     403            rep += "number fittable_param(self.fittable_param): %s\n"%len(temp_fittable_param) 
     404            rep = self._repr_helper( list=temp_fittable_param, rep=rep)  
     405            """  
     406            if is_2D: 
     407                rep += "number orientation parameters" 
     408                rep += "(self.orientation_params): %s\n"%len(self.orientation_params) 
     409                rep = self._repr_helper( list=self.orientation_params, rep=rep) 
     410                rep += "number dispersity parameters" 
     411                rep += "(self.orientation_params_disp): %s\n"%len(self.orientation_params_disp) 
     412                rep = self._repr_helper( list=self.orientation_params_disp, rep=rep) 
     413            """ 
    380414         
    381415        return rep 
    382     
     416 
     417 
     418    def set_report_string(self): 
     419        """ 
     420        Get the values (strings) from __str__ for report  
     421        """ 
     422        # Dictionary of teh report strings 
     423        repo_time = "" 
     424        model_name = "" 
     425        title = "" 
     426        title_name = "" 
     427        file_name = "" 
     428        param_string = "" 
     429        paramval_string = "" 
     430        chi2_string = "" 
     431        q_range = "" 
     432        strings = self.__repr__() 
     433        lines = strings.split('\n') 
     434 
     435        # get all string values from __str__() 
     436        for line in lines: 
     437            value = "" 
     438            content = line.split(":") 
     439            name = content[0] 
     440            try: 
     441                value = content[1] 
     442            except: 
     443                pass 
     444            if name.count("State created on"): 
     445                repo_time = "Created on " + value 
     446            if name.count("parameter name"): 
     447                val_name = value.split(".") 
     448                if len(val_name) > 1: 
     449                    if val_name[1].count("width"): 
     450                        param_string += value + ',' 
     451                    else: 
     452                        continue 
     453                else: 
     454                    param_string += value + ',' 
     455            if name == "value": 
     456                param_string += value + ',' 
     457            if name == "error value": 
     458                param_string += value + ',' 
     459            if name == "parameter unit": 
     460                param_string += value + ':'  
     461            if name == "Value of Chisqr ": 
     462                chi2 = ("Chi2/Npts = " + value) 
     463                chi2_string = CENTRE % chi2 
     464            if name == "Title": 
     465                if len(value.strip()) == 0: 
     466                    continue 
     467                title = value + " [" + repo_time + "]" 
     468                title_name = HEADER % title 
     469            if name == "data ": 
     470                try: 
     471                    file = ("File name:" + content[2]) 
     472                    file_name = CENTRE % file 
     473                    if len(title) == 0: 
     474                        title = content[2] + " [" + repo_time + "]" 
     475                        title_name = HEADER % title 
     476                except: 
     477                    pass 
     478            if name == "Plotting Range": 
     479                try: 
     480                    q_range = content[1] + " = " + content[2] \ 
     481                            + " = " + content[3].split(",")[0] 
     482                    q_name = ("Q Range:    " + q_range) 
     483                    q_range = CENTRE % q_name 
     484                except: 
     485                    pass 
     486        paramval = "" 
     487        for lines in param_string.split(":"):  
     488            line = lines.split(",") 
     489            if len(lines) > 0:  
     490                param = line[0]  
     491                param += " = " + line[1] 
     492                if len(line[2].split()) > 0 and not line[2].count("None"): 
     493                    param += " +- " + line[2] 
     494                if len(line[3].split()) > 0 and not line[3].count("None"): 
     495                    param += " " + line[3] 
     496                if not paramval.count(param): 
     497                    paramval +=  param + "\n" 
     498                    paramval_string += CENTRE % param + "\n" 
     499         
     500        html_string = title_name + "\n" + file_name + \ 
     501                                   "\n" + q_range + \ 
     502                                   "\n" + chi2_string + \ 
     503                                   "\n" + ELINE + \ 
     504                                   "\n" + paramval_string + \ 
     505                                   "\n" + ELINE + \ 
     506                                   "\n" + FEET_1 % title + \ 
     507                                   "\n" + FEET_2  
     508                             
     509        text_string = "\n\n\n" + title + "\n\n" + file + \ 
     510                              "\n" + q_name + \ 
     511                              "\n" + chi2 + \ 
     512                              "\n\n" + paramval  
     513                                            
     514        return html_string, text_string, title 
     515     
     516    def report(self, figs=None, canvases=None): 
     517        """ 
     518        Invoke report dialog panel 
     519         
     520        : param figs: list of pylab figures [list] 
     521        """ 
     522        from report_dialog import ReportDialog 
     523        # get the strings for report 
     524        html_str, text_str, title = self.set_report_string() 
     525        # Allow 2 figures to append 
     526        if len(figs) == 1: 
     527            add_str = FEET_3  
     528        elif len(figs) == 2: 
     529            add_str = ELINE  
     530            add_str += FEET_2 % ("%s")  
     531            add_str += ELINE  
     532            add_str += FEET_3  
     533        elif len(figs) > 2: 
     534            add_str = ELINE  
     535            add_str += FEET_2 % ("%s")  
     536            add_str += ELINE  
     537            add_str += FEET_2 % ("%s")  
     538            add_str += ELINE  
     539            add_str += FEET_3  
     540        else: 
     541            add_str = "" 
     542        # final report html strings 
     543        report_str = html_str % ("%s") + add_str 
     544 
     545        # make plot image 
     546        images = self.set_plot_state(figs, canvases) 
     547        report_list = [report_str, text_str, images ] 
     548        dialog = ReportDialog(report_list, None, -1, "") 
     549        dialog.ShowModal() 
     550           
    383551    def _toXML_helper(self, list, element, newdoc): 
    384552        """ 
    … …  
    463631        for item in list_of_data_attributes: 
    464632            element = newdoc.createElement(item[0]) 
    465             exec "element.setAttribute(item[0], str(self.%s))"%(item[1]) 
     633            exec "element.setAttribute(item[0], str(self.%s))" % (item[1]) 
    466634            inputs.appendChild(element)    
    467635         
    468636        for item in list_of_state_attributes: 
    469637            element = newdoc.createElement(item[0]) 
    470             exec "element.setAttribute(item[0], str(self.%s))"%(item[1]) 
     638            exec "element.setAttribute(item[0], str(self.%s))" % (item[1]) 
    471639            inputs.appendChild(element) 
    472              
     640 
     641        # For self.values ={ disp_param_name: [vals,...],...}    
     642        # and for self.weights ={ disp_param_name: [weights,...],...}               
    473643        for item in list_of_model_attributes: 
    474644            element = newdoc.createElement(item[0]) 
    475             exec "list = self.%s"%item[1] 
    476             for value in list: 
    477                 exec "element.appendChild(newdoc.createTextNode(str(%s)))"%value 
     645            exec "list = self.%s" % item[1] 
     646            for key, value in list.iteritems(): 
     647                sub_element = newdoc.createElement(key) 
     648                sub_element.setAttribute('name', str(key)) 
     649                for val in value: 
     650                    com = "sub_element.appendChild" 
     651                    com += "(newdoc.createTextNode(str(%s)))" 
     652                    exec com % val 
     653                    
     654                element.appendChild(sub_element)  
    478655            inputs.appendChild(element) 
    479              
     656         
     657        # Create doc for the dictionary of self._disp_obj_dic 
     658        for item in list_of_obj_dic: 
     659             element = newdoc.createElement(item[0]) 
     660             exec "list = self.%s" % item[1] 
     661             for key, val in list.iteritems(): 
     662                 value = repr(val) 
     663                 sub_element = newdoc.createElement(key) 
     664                 sub_element.setAttribute('name', str(key)) 
     665                 sub_element.setAttribute('value', str(value)) 
     666                 element.appendChild(sub_element)  
     667             inputs.appendChild(element)     
     668                  
    480669        for item in list_of_state_parameters: 
    481670            element = newdoc.createElement(item[0]) 
    482             exec "self._toXML_helper(list=self.%s, element=element, newdoc=newdoc)"%item[1]                        
     671            com = "self._toXML_helper(list=self.%s," 
     672            com += " element=element, newdoc=newdoc)" 
     673            exec com % item[1]                        
    483674            inputs.appendChild(element) 
    484         
     675                
    485676        # Save the file 
    486677        if doc is None: 
    … …  
    537728            except: 
    538729                unit = None 
    539             list.append([selected_to_fit, name, value, "+/-",[error_displayed, error_value], 
    540                          [minimum_displayed,minimum_value],[maximum_displayed,maximum_value], unit]) 
     730            list.append([selected_to_fit, name, value, "+/-", 
     731                         [error_displayed, error_value], 
     732                         [minimum_displayed,minimum_value], 
     733                         [maximum_displayed,maximum_value], unit]) 
    541734        
    542735    def fromXML(self, file=None, node=None): 
    … …  
    575768                node = get_content('ns:%s'%item[0], entry) 
    576769                try: 
    577                     exec "self.%s = parse_entry_helper(node, item)"%item[0] 
     770                    exec "self.%s = parse_entry_helper(node, item)" % item[0] 
    578771                     
    579772                except: 
    580773                    raise 
    581              
     774 
    582775            if entry is not None: 
    583776                 
    584777                for item in list_of_state_attributes: 
    585                     node = get_content('ns:%s'%item[0], entry) 
     778                    node = get_content('ns:%s' % item[0], entry) 
    586779                    try: 
    587                         exec "self.%s = parse_entry_helper(node, item)"%str(item[0]) 
     780                        exec "self.%s = parse_entry_helper(node, item)" % \ 
     781                                                                str(item[0]) 
    588782                    except: 
    589783                        raise 
    590784                     
     785                for item in list_of_state_parameters: 
     786                    node = get_content("ns:%s" % item[0], entry) 
     787                    exec "self._fromXML_helper(node=node, list=self.%s)" % \ 
     788                                                                    item[1] 
     789                 
     790                # Recover _disp_obj_dict from xml file    
     791                self._disp_obj_dict = {}     
     792                for item in list_of_obj_dic: 
     793                    # Get node 
     794                    node = get_content("ns:%s" % item[0], entry) 
     795                    for attr in node: 
     796                        name = attr.get('name') 
     797                        val  = attr.get('value') 
     798                        value = val.split(" instance")[0] 
     799                        disp_name = value.split("<")[1] 
     800                        try: 
     801                            # Try to recover disp_model object from strings 
     802                            com  = "from sans.models.dispersion_models " 
     803                            com += "import %s as disp" 
     804                            com_name = disp_name.split(".")[3] 
     805                            exec com % com_name 
     806                            disp_model = disp() 
     807                            exec "self.%s['%s'] = com_name" % (item[1], name) 
     808                        except: 
     809                            pass 
     810                         
     811                # get self.values and self.weights dic. if exists     
    591812                for item in list_of_model_attributes: 
    592                     node = get_content("ns:%s"%item[0], entry) 
     813                    node = get_content("ns:%s" % item[0], entry) 
     814                    dic = {} 
    593815                    list = [] 
    594                     for value in node: 
    595                         try: 
    596                             list.append(float(value))  
    597                         except: 
    598                             list.append(None) 
    599                     exec "self.%s = list"%item[1] 
    600                  
    601                 for item in list_of_state_parameters: 
    602                     node = get_content("ns:%s"%item[0], entry) 
    603                     exec "self._fromXML_helper(node=node, list=self.%s)"%item[1] 
    604                     
     816                    for par in node: 
     817                        name = par.get('name') 
     818                        values = par.text.split('\n') 
     819                        # Get lines only with numbers 
     820                        for line in values: 
     821                            try: 
     822                                val= float(line) 
     823                                list.append(val)  
     824                            except: 
     825                                # pass if line is empty (it happens) 
     826                                pass 
     827                    dic[name] = numpy.array(list) 
     828                    exec "self.%s = dic" % item[1] 
     829                     
     830    def set_plot_state(self, figs, canvases): 
     831        """ 
     832        Build image state that wx.html understand 
     833        by plotting, putting it into wx.FileSystem image object 
     834 
     835        """ 
     836        images = [] 
     837        # some imports 
     838        import wx 
     839 
     840        # Reset memory 
     841        self.imgRAM = None 
     842        wx.MemoryFSHandler() 
     843         
     844        # For no figures in the list, prepare empty plot 
     845        if figs == None or len(figs) == 0: 
     846            figs = [None] 
     847             
     848        # Loop over the list of figures    
     849        # use wx.MemoryFSHandler 
     850        self.imgRAM = wx.MemoryFSHandler()  
     851        for fig in figs: 
     852            if figs != None: 
     853                #fig.set_facecolor('w') 
     854                ind = figs.index(fig) 
     855                canvas = canvases[ind] 
     856                 
     857            #bmp = wx.BitmapDataObject() 
     858            #bmp.SetBitmap(canvas.bitmap) 
     859            #store the image in wx.FileSystem Object  
     860            wx.FileSystem.AddHandler(wx.MemoryFSHandler()) 
     861             
     862            # index of the fig 
     863            ind = figs.index(fig) 
     864             
     865            #AddFile, image can be retrieved with 'memory:filename' 
     866            self.imgRAM.AddFile('img_fit%s.png' % ind ,  
     867                                canvas.bitmap, wx.BITMAP_TYPE_PNG) 
     868             
     869            #append figs 
     870            images.append(fig) 
     871             
     872        return images                    
    605873 
    606874class Reader(CansasReader): 
    … …  
    12331501             
    12341502        return doc  
    1235    
     1503 
     1504     
     1505# Simple html report templet   
     1506HEADER = "<html>\n" 
     1507HEADER += "<head>\n" 
     1508HEADER += "<meta http-equiv=Content-Type content='text/html; " 
     1509HEADER += "charset=windows-1252'> \n" 
     1510HEADER += "<meta name=Generator >\n" 
     1511HEADER += "</head>\n" 
     1512HEADER += "<body lang=EN-US>\n" 
     1513HEADER += "<div class=WordSection1>\n" 
     1514HEADER += "<p class=MsoNormal><b><span ><center>" 
     1515HEADER += "%s</center></span></center></b></p>" 
     1516HEADER += "<p class=MsoNormal>&nbsp;</p>" 
     1517PARA = "<p class=MsoNormal> %s \n" 
     1518PARA += "</p>" 
     1519CENTRE = "<p class=MsoNormal><center> %s \n" 
     1520CENTRE += "</center></p>" 
     1521FEET_1 = \ 
     1522""" 
     1523<p class=MsoNormal>&nbsp;</p> 
     1524<p class=MsoNormal><b><span ><center> Graph</span></center></b></p>  
     1525<p class=MsoNormal>&nbsp;</p>  
     1526<center>  
     1527<br>Model Computation<br>  
     1528<br>Data: "%s"<br>  
     1529""" 
     1530FEET_2 = \ 
     1531""" 
     1532<img src="%s" >  
     1533</img> 
     1534""" 
     1535FEET_3 = \ 
     1536""" 
     1537</center>  
     1538</div> 
     1539</body> 
     1540</html> 
     1541""" 
     1542ELINE = "<p class=MsoNormal>&nbsp;</p>" 
     1543 
     1544  
    12361545if __name__ == "__main__": 
    12371546    state = PageState(parent=None) 

  • sansview/perspectives/fitting/simfitpage.py

    r66ff250 r2296316  
    234234        #------------------------------------------------------ 
    235235        if len(self.page_finder)==0: 
    236             sizer_title.Add(wx.StaticText(self,-1," No fit combinations are found!")) 
     236            msg = " No fit combinations are found! \n\n" 
     237            msg += " Please load data and set up at least two fit panels first..." 
     238            sizer_title.Add(wx.StaticText(self, -1, msg)) 
    237239        else: 
    238240            ## store model   
Note: See TracChangeset for help on using the changeset viewer.