Changeset c44bb26a in sasview for src/sas


Ignore:
Timestamp:
Apr 11, 2017 9:41:48 AM (8 years ago)
Author:
butler
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.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
fc6651c
Parents:
426df2e (diff), 97c60f8 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge remote-tracking branch 'origin/master' into FixingTicket741

Location:
src/sas/sasgui
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sasgui/guiframe/gui_manager.py

    r49165488 r38beeab  
    7777    # clean all these module variables and put them into a config class 
    7878    # that can be passed by sasview.py. 
    79     logger.info(sys.executable) 
    80     logger.info(str(sys.argv)) 
     79    logger.debug(sys.executable) 
     80    logger.debug(str(sys.argv)) 
    8181    from sas import sasview as sasview 
    8282    app_path = os.path.dirname(sasview.__file__) 
    83     logger.info("Using application path: %s", app_path) 
     83    logger.debug("Using application path: %s", app_path) 
    8484    return app_path 
    8585 
     
    109109        if fObj is not None: 
    110110            fObj.close() 
    111     logger.info("GuiManager loaded %s/%s" % (path, file)) 
     111    logger.debug("GuiManager loaded %s/%s" % (path, file)) 
    112112    return config_module 
    113113 
     
    126126        # Didn't find local config, load the default 
    127127        import sas.sasgui.guiframe.config as config 
    128         logger.info("using default local_config") 
     128        logger.debug("using default local_config") 
    129129    else: 
    130         logger.info("found local_config in %s" % os.getcwd()) 
     130        logger.debug("found local_config in %s" % os.getcwd()) 
    131131else: 
    132     logger.info("found local_config in %s" % PATH_APP) 
     132    logger.debug("found local_config in %s" % PATH_APP) 
    133133 
    134134from sas.sasgui.guiframe.customdir import SetupCustom 
     
    139139    if custom_config is None: 
    140140        msgConfig = "Custom_config file was not imported" 
    141         logger.info(msgConfig) 
     141        logger.debug(msgConfig) 
    142142    else: 
    143         logger.info("using custom_config in %s" % os.getcwd()) 
     143        logger.debug("using custom_config in %s" % os.getcwd()) 
    144144else: 
    145     logger.info("using custom_config from %s" % c_conf_dir) 
     145    logger.debug("using custom_config from %s" % c_conf_dir) 
    146146 
    147147# read some constants from config 
     
    21562156        if response is not None: 
    21572157            try: 
    2158                 #  
    21592158                content = response.read().strip() 
    2160                 logger.info("Connected to www.sasview.org. Latest version: %s" 
    2161                              % (content)) 
     2159                logger.info("Connected to www.sasview.org. Latest version: %s", content) 
    21622160                version_info = json.loads(content) 
    21632161            except: 
  • src/sas/sasgui/perspectives/calculator/sld_panel.py

    r7432acb r2d220dd  
    6060        # Object that receive status event 
    6161        self.base = base 
    62         self.wavelength = WAVELENGTH 
     62        self.neutron_wavelength = WAVELENGTH 
     63        self.xray_source_input = WAVELENGTH 
    6364        self.parent = parent 
    6465        #layout attribute 
     
    6768        self.compound = "" 
    6869        self.density = "" 
    69         self.wavelength_ctl = None 
     70        self.neutron_wavelength_ctl = None 
     71        self.xray_source_input_ctl = None 
     72        self.xray_cbox = None 
    7073        self.neutron_sld_real_ctl = None 
    7174        self.neutron_sld_im_ctl = None 
    72         self.mo_ka_sld_real_ctl = None 
    73         self.mo_ka_sld_im_ctl = None 
    74         self.cu_ka_sld_real_ctl = None 
    75         self.cu_ka_sld_im_ctl = None 
     75        self.xray_sld_real_ctl = None 
     76        self.xray_sld_im_ctl = None 
    7677        self.neutron_abs_ctl = None 
    7778        self.neutron_inc_ctl = None 
    7879        self.neutron_length_ctl = None 
    7980        self.button_calculate = None 
     81        self.xray_source = None 
    8082        #Draw the panel 
    8183        self._do_layout() 
    8284        self.SetAutoLayout(True) 
    8385        self.Layout() 
     86        self.fill_xray_cbox() 
    8487 
    8588    def _do_layout(self): 
     
    108111        self.density_ctl = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, -1)) 
    109112        unit_density_txt = wx.StaticText(self, -1, unit_density) 
    110         wavelength_txt = wx.StaticText(self, -1, 'Wavelength ') 
    111         self.wavelength_ctl = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, -1)) 
    112         self.wavelength_ctl.SetValue(str(self.wavelength)) 
    113         unit_a_txt = wx.StaticText(self, -1, unit_a) 
     113        neutron_wavelength_txt = wx.StaticText(self, -1, 'Neutron wavelength') 
     114        self.neutron_wavelength_ctl = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, -1)) 
     115        self.neutron_wavelength_ctl.SetValue(str(self.neutron_wavelength)) 
     116        self.xray_source_input_txt = wx.StaticText(self, -1, 'X-ray wavelength') 
     117        self.xray_source_input_ctl = wx.TextCtrl(self, -1, size=(_BOX_WIDTH, -1)) 
     118        self.xray_source_input_ctl.SetValue(str(self.xray_source_input)) 
     119        neutron_unit_a_txt = wx.StaticText(self, -1, unit_a) 
     120 
     121        self.xray_cbox = wx.ComboBox(self, -1, size=(70, 20), style=wx.CB_READONLY) 
     122        xray_cbox_tip = "Select an element, wavelength or energy" 
     123        self.xray_cbox.SetToolTipString(xray_cbox_tip) 
     124        wx.EVT_COMBOBOX(self.xray_cbox, -1, self.on_select_xray) 
     125 
    114126        iy = 0 
    115127        ix = 0 
     
    131143        iy += 1 
    132144        ix = 0 
    133         sizer_input.Add(wavelength_txt, (iy, ix), (1, 1), 
    134                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
    135         ix += 1 
    136         sizer_input.Add(self.wavelength_ctl, (iy, ix), (1, 1), 
    137                             wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    138         ix += 1 
    139         sizer_input.Add(unit_a_txt, (iy, ix), (1, 1), 
     145        sizer_input.Add(neutron_wavelength_txt, (iy, ix), (1, 1), 
     146                             wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
     147        ix += 1 
     148        sizer_input.Add(self.neutron_wavelength_ctl, (iy, ix), (1, 1), 
     149                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
     150        ix += 1 
     151        sizer_input.Add(neutron_unit_a_txt, (iy, ix), (1, 1), 
     152                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
     153        iy += 1 
     154        ix = 0 
     155        sizer_input.Add(self.xray_source_input_txt, (iy, ix), (1, 1), 
     156                             wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
     157        ix += 1 
     158        sizer_input.Add(self.xray_source_input_ctl, (iy, ix), (1, 1), 
     159                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
     160        ix += 1 
     161        sizer_input.Add(self.xray_cbox, (iy, ix), (1, 1), 
    140162                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    141163        boxsizer1.Add(sizer_input) 
     
    151173                                                 size=(_BOX_WIDTH, -1)) 
    152174        self.neutron_sld_real_ctl.SetEditable(False) 
    153         self.neutron_sld_real_ctl.SetToolTipString("Neutron SLD real.") 
     175        self.neutron_sld_real_ctl.SetToolTipString("Neutron SLD real") 
    154176        self.neutron_sld_im_ctl = wx.TextCtrl(self, -1, 
    155177                                              size=(_BOX_WIDTH, -1)) 
    156178        self.neutron_sld_im_ctl.SetEditable(False) 
    157         self.neutron_sld_im_ctl.SetToolTipString("Neutron SLD imaginary.") 
     179        self.neutron_sld_im_ctl.SetToolTipString("Neutron SLD imaginary") 
    158180        neutron_sld_units_txt = wx.StaticText(self, -1, unit_sld) 
    159181 
    160         cu_ka_sld_txt = wx.StaticText(self, -1, 'Cu Ka SLD') 
    161         self.cu_ka_sld_real_ctl = wx.TextCtrl(self, -1, 
     182        xray_sld_txt = wx.StaticText(self, -1, 'X-ray SLD') 
     183        self.xray_sld_real_ctl = wx.TextCtrl(self, -1, 
    162184                                               size=(_BOX_WIDTH, -1)) 
    163         self.cu_ka_sld_real_ctl.SetEditable(False) 
    164         self.cu_ka_sld_real_ctl.SetToolTipString("Cu Ka SLD real.") 
    165         self.cu_ka_sld_im_ctl = wx.TextCtrl(self, -1, 
     185        self.xray_sld_real_ctl.SetEditable(False) 
     186        self.xray_sld_real_ctl.SetToolTipString("X-ray SLD real") 
     187        self.xray_sld_im_ctl = wx.TextCtrl(self, -1, 
    166188                                            size=(_BOX_WIDTH, -1)) 
    167         self.cu_ka_sld_im_ctl.SetEditable(False) 
    168         self.cu_ka_sld_im_ctl.SetToolTipString("Cu Ka SLD imaginary.") 
    169         cu_ka_sld_units_txt = wx.StaticText(self, -1, unit_sld) 
    170  
    171         mo_ka_sld_txt = wx.StaticText(self, -1, 'Mo Ka SLD') 
    172         self.mo_ka_sld_real_ctl = wx.TextCtrl(self, -1, 
    173                                                size=(_BOX_WIDTH, -1)) 
    174         self.mo_ka_sld_real_ctl.SetEditable(False) 
    175         self.mo_ka_sld_real_ctl.SetToolTipString("Mo Ka SLD real.") 
    176         self.mo_ka_sld_im_ctl = wx.TextCtrl(self, -1, 
    177                                              size=(_BOX_WIDTH, -1)) 
    178         self.mo_ka_sld_im_ctl.SetEditable(False) 
    179         self.mo_ka_sld_im_ctl.SetToolTipString("Mo Ka SLD imaginary.") 
    180         mo_ka_sld_units_txt = wx.StaticText(self, -1, unit_sld) 
     189        self.xray_sld_im_ctl.SetEditable(False) 
     190        self.xray_sld_im_ctl.SetToolTipString("X-ray SLD imaginary") 
     191        xray_sld_units_txt = wx.StaticText(self, -1, unit_sld) 
    181192 
    182193        neutron_inc_txt = wx.StaticText(self, -1, 'Neutron Inc. Xs') 
     
    219230        iy += 1 
    220231        ix = 0 
    221         sizer_output.Add(cu_ka_sld_txt, (iy, ix), (1, 1), 
    222                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
    223         ix += 1 
    224         sizer_output.Add(self.cu_ka_sld_real_ctl, (iy, ix), (1, 1), 
     232        sizer_output.Add(xray_sld_txt, (iy, ix), (1, 1), 
     233                             wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
     234        ix += 1 
     235        sizer_output.Add(self.xray_sld_real_ctl, (iy, ix), (1, 1), 
    225236                            wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    226237        ix += 1 
     
    228239                         (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    229240        ix += 1 
    230         sizer_output.Add(self.cu_ka_sld_im_ctl, 
     241        sizer_output.Add(self.xray_sld_im_ctl, 
    231242                         (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    232243        ix += 1 
    233         sizer_output.Add(cu_ka_sld_units_txt, 
    234                          (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    235         iy += 1 
    236         ix = 0 
    237         sizer_output.Add(mo_ka_sld_txt, (iy, ix), (1, 1), 
    238                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 15) 
    239         ix += 1 
    240         sizer_output.Add(self.mo_ka_sld_real_ctl, (iy, ix), (1, 1), 
    241                             wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    242         ix += 1 
    243         sizer_output.Add(wx.StaticText(self, -1, i_complex), 
    244                          (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    245         ix += 1 
    246         sizer_output.Add(self.mo_ka_sld_im_ctl, 
    247                          (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    248         ix += 1 
    249         sizer_output.Add(mo_ka_sld_units_txt, 
     244        sizer_output.Add(xray_sld_units_txt, 
    250245                         (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    251246        iy += 1 
     
    310305        self.SetSizer(vbox) 
    311306 
     307    def fill_xray_cbox(self): 
     308        """ 
     309        fill the x-ray combobox with the sources 
     310        """ 
     311        source_list = ['[A]', '[keV]', 'Element'] 
     312        for source in source_list: 
     313            pos = self.xray_cbox.Append(str(source)) 
     314            self.xray_cbox.SetClientData(pos, str(source.strip())) 
     315        self.xray_cbox.SetSelection(0) 
     316        self.xray_source = source_list[0] 
     317 
     318    def on_select_xray(self, event=None): 
     319        """ 
     320        On Selecting a source 
     321        """ 
     322        item = event.GetEventObject() 
     323        self.xray_source = item.GetValue().strip() 
     324 
     325        if self.xray_source == "[A]": 
     326            self.xray_source_input_txt.SetLabel("X-ray wavelength") 
     327        elif self.xray_source == "[keV]": 
     328            self.xray_source_input_txt.SetLabel("X-ray energy") 
     329        elif self.xray_source == "Element": 
     330            self.xray_source_input_txt.SetLabel("X-ray source") 
     331 
    312332    def on_help(self, event): 
    313333        """ 
     
    363383            msg += "Error for Density value :expect float" 
    364384 
    365         self.wavelength = self.wavelength_ctl.GetValue() 
    366         if str(self.wavelength).lstrip().rstrip() == "": 
    367             self.wavelength = WAVELENGTH 
    368             self.wavelength_ctl.SetValue(str(WAVELENGTH)) 
    369             self.wavelength_ctl.SetBackgroundColour(wx.WHITE) 
    370             self.wavelength_ctl.Refresh() 
     385        self.neutron_wavelength = self.neutron_wavelength_ctl.GetValue() 
     386        self.xray_source_input = self.xray_source_input_ctl.GetValue() 
     387 
     388        if str(self.neutron_wavelength).lstrip().rstrip() == "": 
     389            self.neutron_wavelength = WAVELENGTH 
     390            self.neutron_wavelength_ctl.SetValue(str(WAVELENGTH)) 
     391            self.neutron_wavelength_ctl.SetBackgroundColour(wx.WHITE) 
     392            self.neutron_wavelength_ctl.Refresh() 
    371393            msg += "Default value for wavelength is 6.0" 
    372394        else: 
    373             if check_float(self.wavelength_ctl): 
    374                 self.wavelength = float(self.wavelength) 
     395            if check_float(self.neutron_wavelength_ctl): 
     396                self.neutron_wavelength = float(self.neutron_wavelength) 
    375397            else: 
    376398                flag = False 
    377399                msg += "Error for wavelength value :expect float" 
     400 
     401        if str(self.xray_source_input).lstrip().rstrip() == "": 
     402            self.xray_source_input = WAVELENGTH 
     403            self.xray_source_input_ctl.SetValue(str(WAVELENGTH)) 
     404            self.xray_source_input_ctl.SetBackgroundColour(wx.WHITE) 
     405            self.xray_source_input_ctl.Refresh() 
     406            msg += "Default value for wavelength is 6.0" 
     407        else: 
     408            if (self.xray_source == '[A]') or (self.xray_source == '[keV]'): 
     409                if check_float(self.xray_source_input_ctl): 
     410                    self.xray_source_input = float(self.xray_source_input) 
     411                else: 
     412                    flag = False 
     413                    msg += "Error for wavelength value :expect float" 
     414            elif (self.xray_source == 'Element'): 
     415                try: 
     416                    import periodictable 
     417                    exec("periodictable." + self.xray_source_input) 
     418                except AttributeError: 
     419                    flag = False 
     420                    msg += "X-ray element supplied isn't in the database" 
     421 
     422 
    378423 
    379424        self.compound = self.compound_ctl.GetValue().lstrip().rstrip() 
     
    410455        return xray_sld_from_atoms(atom, density=density, energy=energy) 
    411456 
    412  
    413457    def calculateSld(self, event): 
    414458        """ 
     
    430474                        length = neutron_scattering(compound=self.compound, 
    431475                                   density=self.density, 
    432                                    wavelength=self.wavelength) 
    433             cu_real, cu_im = self.calculate_sld_helper(element="Cu", 
    434                                                  density=self.density, 
    435                                         molecule_formula=self.sld_formula) 
    436             mo_real, mo_im = self.calculate_sld_helper(element="Mo", 
    437                                                        density=self.density, 
    438                                      molecule_formula=self.sld_formula) 
     476                                   wavelength=self.neutron_wavelength) 
     477            if self.xray_source == "[A]": 
     478                energy = xray_energy(self.xray_source_input) 
     479                xray_real, xray_im = xray_sld_from_atoms(self.sld_formula.atoms, 
     480                                                         density=self.density, 
     481                                                         energy=energy) 
     482            elif self.xray_source == "[keV]": 
     483                xray_real, xray_im = xray_sld_from_atoms(self.sld_formula.atoms, 
     484                                                         density=self.density, 
     485                                                         energy=self.xray_source_input) 
     486            elif self.xray_source == "Element": 
     487                xray_real, xray_im = self.calculate_sld_helper(element=self.xray_source_input, 
     488                                                               density=self.density, 
     489                                                               molecule_formula=self.sld_formula) 
    439490            # set neutron sld values 
    440491            val = format_number(sld_real * _SCALE) 
     
    443494            self.neutron_sld_im_ctl.SetValue(val) 
    444495            # Compute the Cu SLD 
    445             self.cu_ka_sld_real_ctl.SetValue(format_number(cu_real * _SCALE)) 
    446             val = format_number(math.fabs(cu_im) * _SCALE) 
    447             self.cu_ka_sld_im_ctl.SetValue(val) 
    448             # Compute the Mo SLD 
    449             self.mo_ka_sld_real_ctl.SetValue(format_number(mo_real * _SCALE)) 
    450             val = format_number(math.fabs(mo_im) * _SCALE) 
    451             self.mo_ka_sld_im_ctl.SetValue(val) 
     496            self.xray_sld_real_ctl.SetValue(format_number(xray_real * _SCALE)) 
     497            val = format_number(math.fabs(xray_im) * _SCALE) 
     498            self.xray_sld_im_ctl.SetValue(val) 
    452499            # set incoherence and absorption 
    453500            self.neutron_inc_ctl.SetValue(format_number(incoh)) 
     
    456503            self.neutron_length_ctl.SetValue(format_number(length)) 
    457504            # display wavelength 
    458             self.wavelength_ctl.SetValue(str(self.wavelength)) 
     505            #self.wavelength_ctl.SetValue(str(self.wavelength)) 
     506            #self.wavelength_ctl.SetValue(str(self.wavelength)) 
    459507        except: 
    460508            if self.base is not None: 
     
    470518        self.neutron_sld_real_ctl.SetValue("") 
    471519        self.neutron_sld_im_ctl.SetValue("") 
    472         self.mo_ka_sld_real_ctl.SetValue("") 
    473         self.mo_ka_sld_im_ctl.SetValue("") 
    474         self.cu_ka_sld_real_ctl.SetValue("") 
    475         self.cu_ka_sld_im_ctl.SetValue("") 
     520        self.xray_sld_real_ctl.SetValue("") 
     521        self.xray_sld_im_ctl.SetValue("") 
    476522        self.neutron_abs_ctl.SetValue("") 
    477523        self.neutron_inc_ctl.SetValue("") 
  • src/sas/sasgui/perspectives/fitting/fitting.py

    r7432acb r426df2e  
    359359                                   'Add a new model function') 
    360360        wx.EVT_MENU(owner, wx_id, self.make_new_model) 
    361          
     361 
    362362        wx_id = wx.NewId() 
    363363        self.edit_model_menu.Append(wx_id, 'Sum|Multi(p1, p2)', 
     
    381381          '(Re)Load all models present in user plugin_models folder') 
    382382        wx.EVT_MENU(owner, wx_id, self.load_plugin_models) 
    383                  
     383    
    384384    def set_edit_menu_helper(self, owner=None, menu=None): 
    385385        """ 
     
    17471747                                          data_id="Data  " + data.name + " unsmeared", 
    17481748                                          dy=unsmeared_error) 
    1749             # Comment this out until we can get P*S models with correctly populated parameters 
    1750             #if sq_model is not None and pq_model is not None: 
    1751             #    self.create_theory_1D(x, sq_model, page_id, model, data, state, 
    1752             #                          data_description=model.name + " S(q)", 
    1753             #                          data_id=str(page_id) + " " + data.name + " S(q)") 
    1754             #    self.create_theory_1D(x, pq_model, page_id, model, data, state, 
    1755             #                          data_description=model.name + " P(q)", 
    1756             #                          data_id=str(page_id) + " " + data.name + " P(q)") 
     1749            if sq_model is not None and pq_model is not None: 
     1750                self.create_theory_1D(x, sq_model, page_id, model, data, state, 
     1751                                      data_description=model.name + " S(q)", 
     1752                                      data_id=str(page_id) + " " + data.name + " S(q)") 
     1753                self.create_theory_1D(x, pq_model, page_id, model, data, state, 
     1754                                      data_description=model.name + " P(q)", 
     1755                                      data_id=str(page_id) + " " + data.name + " P(q)") 
    17571756 
    17581757            current_pg = self.fit_panel.get_page_by_id(page_id) 
     
    19101909                ## and may be the cause of other noted instabilities 
    19111910                ## 
    1912                 ##    -PDB August 12, 2014  
     1911                ##    -PDB August 12, 2014 
    19131912                while self.calc_2D.isrunning(): 
    19141913                    time.sleep(0.1) 
     
    19521951            if (self.calc_1D is not None) and self.calc_1D.isrunning(): 
    19531952                self.calc_1D.stop() 
    1954                 ## stop just raises the flag -- the thread is supposed to  
     1953                ## stop just raises the flag -- the thread is supposed to 
    19551954                ## then kill itself but cannot.  Paul Kienzle came up with 
    19561955                ## this fix to prevent threads from stepping on each other 
     
    19641963                ## a request to stop the computation. 
    19651964                ## It seems thus that the whole thread approach used here 
    1966                 ## May need rethinking   
     1965                ## May need rethinking 
    19671966                ## 
    19681967                ##    -PDB August 12, 2014 
     
    21292128            residuals.dxw = None 
    21302129            residuals.ytransform = 'y' 
    2131             # For latter scale changes  
     2130            # For latter scale changes 
    21322131            residuals.xaxis('\\rm{Q} ', 'A^{-1}') 
    21332132            residuals.yaxis('\\rm{Residuals} ', 'normalized') 
  • src/sas/sasgui/perspectives/fitting/model_thread.py

    r7432acb r426df2e  
    7171                    (self.data.qy_data * self.data.qy_data)) 
    7272 
    73         # For theory, qmax is based on 1d qmax  
     73        # For theory, qmax is based on 1d qmax 
    7474        # so that must be mulitified by sqrt(2) to get actual max for 2d 
    7575        index_model = (self.qmin <= radius) & (radius <= self.qmax) 
     
    9191                self.data.qy_data[index_model] 
    9292            ]) 
    93         output = np.zeros(len(self.data.qx_data)) 
     93        # Initialize output to NaN so masked elements do not get plotted. 
     94        output = np.empty_like(self.data.qx_data) 
    9495        # output default is None 
    9596        # This method is to distinguish between masked 
    9697        #point(nan) and data point = 0. 
    97         output = output / output 
     98        output[:] = np.NaN 
    9899        # set value for self.mask==True, else still None to Plottools 
    99100        output[index_model] = value 
     
    198199            output[index] = self.model.evalDistribution(self.data.x[index]) 
    199200 
     201        x=self.data.x[index] 
     202        y=output[index] 
    200203        sq_values = None 
    201204        pq_values = None 
    202         s_model = None 
    203         p_model = None 
    204205        if isinstance(self.model, MultiplicationModel): 
    205206            s_model = self.model.s_model 
    206207            p_model = self.model.p_model 
    207         elif hasattr(self.model, "get_composition_models"): 
    208             p_model, s_model = self.model.get_composition_models() 
    209  
    210         if p_model is not None and s_model is not None: 
    211             sq_values = np.zeros((len(self.data.x))) 
    212             pq_values = np.zeros((len(self.data.x))) 
    213             sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
    214             pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
     208            sq_values = s_model.evalDistribution(x) 
     209            pq_values = p_model.evalDistribution(x) 
     210        elif hasattr(self.model, "calc_composition_models"): 
     211            results = self.model.calc_composition_models(x) 
     212            if results is not None: 
     213                sq_values = results[0] 
     214                pq_values = results[1] 
     215 
    215216 
    216217        elapsed = time.time() - self.starttime 
    217218 
    218         self.complete(x=self.data.x[index], y=output[index], 
     219        self.complete(x=x, y=y, 
    219220                      page_id=self.page_id, 
    220221                      state=self.state, 
Note: See TracChangeset for help on using the changeset viewer.