Changeset 11b094f in sasview for src/sas/sasgui/perspectives


Ignore:
Timestamp:
Feb 19, 2017 4:02:07 PM (7 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.1.1, release-4.1.2, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
4387385
Parents:
e92a352 (diff), 2510b9b (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 ticket-756

Location:
src/sas/sasgui/perspectives
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sasgui/perspectives/fitting/basepage.py

    re92a352 r11b094f  
    11051105        """ 
    11061106        for key, value in self.master_category_dict.iteritems(): 
     1107            formfactor = state.formfactorcombobox.split(":") 
     1108            if isinstance(formfactor, list): 
     1109                formfactor = formfactor[0] 
    11071110            for list_item in value: 
    1108                 if state.formfactorcombobox in list_item: 
     1111                if formfactor in list_item: 
    11091112                    return self.categorybox.Items.index(key) 
    11101113        return 0 
    … …  
    11521155        self._show_combox_helper() 
    11531156        # select the current model 
    1154         try: 
    1155             # to support older version 
    1156             category_pos = int(state.categorycombobox) 
    1157         except: 
    1158             state.formfactorcombobox = state.formfactorcombobox.lower() 
    1159             state.formfactorcombobox = \ 
    1160                 state.formfactorcombobox.replace('model', '') 
    1161             state.formfactorcombobox = unicode(state.formfactorcombobox) 
    1162             state.categorycombobox = unicode(state.categorycombobox) 
    1163             if state.categorycombobox in self.categorybox.Items: 
    1164                 category_pos = self.categorybox.Items.index( 
    1165                     state.categorycombobox) 
    1166             else: 
    1167                 # Look in master list for model name (model.lower) 
    1168                 category_pos = self.get_cat_combo_box_pos(state) 
     1157        state._convert_to_sasmodels() 
     1158        state.categorycombobox = unicode(state.categorycombobox) 
     1159        if state.categorycombobox in self.categorybox.Items: 
     1160            category_pos = self.categorybox.Items.index( 
     1161                state.categorycombobox) 
     1162        else: 
     1163            # Look in master list for model name (model.lower) 
     1164            category_pos = self.get_cat_combo_box_pos(state) 
    11691165 
    11701166        self.categorybox.Select(category_pos) 
    11711167        self._show_combox(None) 
    1172         try: 
    1173             # to support older version 
    1174             formfactor_pos = int(state.formfactorcombobox) 
    1175         except: 
    1176             formfactor_pos = 0 
    1177             for ind_form in range(self.formfactorbox.GetCount()): 
    1178                 if self.formfactorbox.GetString(ind_form) == \ 
    1179                                                     (state.formfactorcombobox): 
    1180                     formfactor_pos = int(ind_form) 
     1168        from models import PLUGIN_NAME_BASE 
     1169        if self.categorybox.GetValue() == 'Customized Models' \ 
     1170                and PLUGIN_NAME_BASE not in state.formfactorcombobox: 
     1171            state.formfactorcombobox = \ 
     1172                PLUGIN_NAME_BASE + state.formfactorcombobox 
     1173        formfactor_pos = 0 
     1174        for ind_form in range(self.formfactorbox.GetCount()): 
     1175            if self.formfactorbox.GetString(ind_form) == \ 
     1176                                                (state.formfactorcombobox): 
     1177                formfactor_pos = int(ind_form) 
     1178                break 
     1179 
     1180        self.formfactorbox.Select(formfactor_pos) 
     1181 
     1182        structfactor_pos = 0 
     1183        if state.structurecombobox is not None: 
     1184            state.structurecombobox = unicode(state.structurecombobox) 
     1185            for ind_struct in range(self.structurebox.GetCount()): 
     1186                if self.structurebox.GetString(ind_struct) == \ 
     1187                                                (state.structurecombobox): 
     1188                    structfactor_pos = int(ind_struct) 
    11811189                    break 
    1182  
    1183         self.formfactorbox.Select(formfactor_pos) 
    1184  
    1185         structfactor_pos = 0 
    1186         try: 
    1187             # to support older version 
    1188             structfactor_pos = int(state.structurecombobox) 
    1189         except: 
    1190             if state.structurecombobox is not None: 
    1191                 state.structurecombobox = unicode(state.structurecombobox) 
    1192                 for ind_struct in range(self.structurebox.GetCount()): 
    1193                     if self.structurebox.GetString(ind_struct) == \ 
    1194                                                     (state.structurecombobox): 
    1195                         structfactor_pos = int(ind_struct) 
    1196                         break 
    11971190 
    11981191        self.structurebox.SetSelection(structfactor_pos) 
    … …  
    13841377        # self.state.struct_rbutton = self.struct_rbutton.GetValue() 
    13851378        # self.state.plugin_rbutton = self.plugin_rbutton.GetValue() 
    1386         self.state.structurecombobox = self.structurebox.GetLabel() 
    1387         self.state.formfactorcombobox = self.formfactorbox.GetLabel() 
    1388         self.state.categorycombobox = self.categorybox.GetLabel() 
     1379        self.state.structurecombobox = self.structurebox.GetValue() 
     1380        self.state.formfactorcombobox = self.formfactorbox.GetValue() 
     1381        self.state.categorycombobox = self.categorybox.GetValue() 
    13891382 
    13901383        # post state to fit panel 
    … …  
    15871580        if len(statelist) == 0 or len(listtorestore) == 0: 
    15881581            return 
    1589         if len(statelist) != len(listtorestore): 
    1590             return 
    15911582 
    15921583        for j in range(len(listtorestore)): 
    1593             item_page = listtorestore[j] 
    1594             item_page_info = statelist[j] 
    1595             # change the state of the check box for simple parameters 
    1596             if item_page[0] is not None: 
    1597                 item_page[0].SetValue(item_page_info[0]) 
    1598             if item_page[2] is not None: 
    1599                 item_page[2].SetValue(item_page_info[2]) 
    1600                 if item_page[2].__class__.__name__ == "ComboBox": 
    1601                     if item_page_info[2] in self.model.fun_list: 
    1602                         fun_val = self.model.fun_list[item_page_info[2]] 
    1603                         self.model.setParam(item_page_info[1], fun_val) 
    1604             if item_page[3] is not None: 
    1605                 # show or hide text +/- 
    1606                 if item_page_info[2]: 
    1607                     item_page[3].Show(True) 
    1608                 else: 
    1609                     item_page[3].Hide() 
    1610             if item_page[4] is not None: 
    1611                 # show of hide the text crtl for fitting error 
    1612                 if item_page_info[4][0]: 
    1613                     item_page[4].Show(True) 
    1614                     item_page[4].SetValue(item_page_info[4][1]) 
    1615                 else: 
    1616                     item_page[3].Hide() 
    1617             if item_page[5] is not None: 
    1618                 # show of hide the text crtl for fitting error 
    1619                 item_page[5].Show(item_page_info[5][0]) 
    1620                 item_page[5].SetValue(item_page_info[5][1]) 
    1621  
    1622             if item_page[6] is not None: 
    1623                 # show of hide the text crtl for fitting error 
    1624                 item_page[6].Show(item_page_info[6][0]) 
    1625                 item_page[6].SetValue(item_page_info[6][1]) 
     1584            for param in statelist: 
     1585                if param[1] == listtorestore[j][1]: 
     1586                    item_page = listtorestore[j] 
     1587                    item_page_info = param 
     1588                    if (item_page_info[1] == "theta" or item_page_info[1] == 
     1589                            "phi") and not self._is_2D(): 
     1590                        break 
     1591                    # change the state of the check box for simple parameters 
     1592                    if item_page[0] is not None: 
     1593                        item_page[0].SetValue(item_page_info[0]) 
     1594                    if item_page[2] is not None: 
     1595                        item_page[2].SetValue(item_page_info[2]) 
     1596                        if item_page[2].__class__.__name__ == "ComboBox": 
     1597                            if item_page_info[2] in self.model.fun_list: 
     1598                                fun_val = self.model.fun_list[item_page_info[2]] 
     1599                                self.model.setParam(item_page_info[1], fun_val) 
     1600                    if item_page[3] is not None: 
     1601                        # show or hide text +/- 
     1602                        if item_page_info[2]: 
     1603                            item_page[3].Show(True) 
     1604                        else: 
     1605                            item_page[3].Hide() 
     1606                    if item_page[4] is not None: 
     1607                        # show of hide the text crtl for fitting error 
     1608                        if item_page_info[4][0]: 
     1609                            item_page[4].Show(True) 
     1610                            item_page[4].SetValue(str(item_page_info[4][1])) 
     1611                        else: 
     1612                            item_page[3].Hide() 
     1613                    if item_page[5] is not None: 
     1614                        # show of hide the text crtl for fitting error 
     1615                        item_page[5].Show(True) 
     1616                        item_page[5].SetValue(str(item_page_info[5][1])) 
     1617                    if item_page[6] is not None: 
     1618                        # show of hide the text crtl for fitting error 
     1619                        item_page[6].Show(True) 
     1620                        item_page[6].SetValue(str(item_page_info[6][1])) 
     1621                    break 
    16261622 
    16271623    def _reset_strparam_state(self, listtorestore, statelist): 

  • src/sas/sasgui/perspectives/fitting/fitpage.py

    r24fd27a ra6fccd7  
    11901190        self.state.slit_smearer = self.slit_smearer.GetValue() 
    11911191 
    1192         self.state.structurecombobox = self.structurebox.GetLabel() 
    1193         self.state.formfactorcombobox = self.formfactorbox.GetLabel() 
     1192        self.state.structurecombobox = self.structurebox.GetValue() 
     1193        self.state.formfactorcombobox = self.formfactorbox.GetValue() 
     1194        self.state.categorycombobox = self.categorybox.GetValue() 
    11941195        self.enable_fit_button() 
    11951196        if self.model is not None: 

  • src/sas/sasgui/perspectives/fitting/models.py

    re92a352 r11b094f  
    2323PLUGIN_LOG = os.path.join(os.path.expanduser("~"), '.sasview', PLUGIN_DIR, 
    2424                          "plugins.log") 
     25PLUGIN_NAME_BASE = '[plug-in] ' 
    2526 
    2627def get_model_python_path(): 
    … …  
    181182            try: 
    182183                model = load_custom_model(path) 
    183                 model.name = "[plug-in] "+model.name 
     184                model.name = PLUGIN_NAME_BASE + model.name 
    184185                plugins[model.name] = model 
    185186            except Exception: 

  • src/sas/sasgui/perspectives/fitting/pagestate.py

    rc8e1996 r6d2b50b  
    2525from lxml import etree 
    2626 
     27from sasmodels import convert 
    2728import sasmodels.weights 
    2829 
    … …  
    271272        # store value of chisqr 
    272273        self.tcChi = None 
     274        self.version = (1,0,0) 
    273275 
    274276    def clone(self): 
    … …  
    349351        obj.cb1 = copy.deepcopy(self.cb1) 
    350352        obj.smearer = copy.deepcopy(self.smearer) 
     353        obj.version = copy.deepcopy(self.version) 
    351354 
    352355        for name, state in self.saved_states.iteritems(): 
    … …  
    355358            obj.saved_states[copy_name] = copy_state 
    356359        return obj 
     360 
     361    def _old_first_model(self): 
     362        """ 
     363        Handle save states from 4.0.1 and before where the first item in the 
     364        selection boxes of category, formfactor and structurefactor were not 
     365        saved. 
     366        :return: None 
     367        """ 
     368        if self.formfactorcombobox == '': 
     369            FIRST_FORM = { 
     370                'Shapes' : 'BCCrystalModel', 
     371                'Uncategorized' : 'LineModel', 
     372                'StructureFactor' : 'HardsphereStructure', 
     373                'Ellipsoid' : 'core_shell_ellipsoid', 
     374                'Lamellae' : 'lamellar', 
     375                'Paracrystal' : 'bcc_paracrystal', 
     376                'Parallelepiped' : 'core_shell_parallelepiped', 
     377                'Shape Independent' : 'be_polyelectrolyte', 
     378                'Sphere' : 'adsorbed_layer', 
     379                'Structure Factor' : 'hardsphere', 
     380                'Customized Models' : '' 
     381            } 
     382            if self.categorycombobox == '': 
     383                if len(self.parameters) == 3: 
     384                    self.categorycombobox = "Shape-Independent" 
     385                    self.formfactorcombobox = 'PowerLawAbsModel' 
     386                elif len(self.parameters) == 9: 
     387                    self.categorycombobox = 'Cylinder' 
     388                    self.formfactorcombobox = 'barbell' 
     389                else: 
     390                    msg = "Save state does not have enough information to load" 
     391                    msg += " the all of the data." 
     392                    logging.warning(msg=msg) 
     393            else: 
     394                self.formfactorcombobox = FIRST_FORM[self.categorycombobox] 
     395 
     396    @staticmethod 
     397    def param_remap_to_sasmodels_convert(params, is_string=False): 
     398        """ 
     399        Remaps the parameters for sasmodels conversion 
     400 
     401        :param params: list of parameters (likely self.parameters) 
     402        :return: remapped dictionary of parameters 
     403        """ 
     404        p = dict() 
     405        for fittable, name, value, _, uncert, lower, upper, units in params: 
     406            if not value: 
     407                value = numpy.nan 
     408            if not uncert or uncert[1] == '' or uncert[1] == 'None': 
     409                uncert[0] = False 
     410                uncert[1] = numpy.nan 
     411            if not upper or upper[1] == '' or upper[1] == 'None': 
     412                upper[0] = False 
     413                upper[1] = numpy.nan 
     414            if not lower or lower[1] == '' or lower[1] == 'None': 
     415                lower[0] = False 
     416                lower[1] = numpy.nan 
     417            if is_string: 
     418                p[name] = str(value) 
     419            else: 
     420                p[name] = float(value) 
     421            p[name + ".fittable"] = bool(fittable) 
     422            p[name + ".std"] = float(uncert[1]) 
     423            p[name + ".upper"] = float(upper[1]) 
     424            p[name + ".lower"] = float(lower[1]) 
     425            p[name + ".units"] = units 
     426        return p 
     427 
     428    @staticmethod 
     429    def param_remap_from_sasmodels_convert(params): 
     430        """ 
     431        Converts {name : value} map back to [] param list 
     432        :param params: parameter map returned from sasmodels 
     433        :return: None 
     434        """ 
     435        p_map = [] 
     436        for name, info in params.iteritems(): 
     437            if ".fittable" in name or ".std" in name or ".upper" in name or \ 
     438                            ".lower" in name or ".units" in name: 
     439                pass 
     440            else: 
     441                fittable = params.get(name + ".fittable", True) 
     442                std = params.get(name + ".std", '0.0') 
     443                upper = params.get(name + ".upper", 'inf') 
     444                lower = params.get(name + ".lower", '-inf') 
     445                units = params.get(name + ".units") 
     446                if std is not None and std is not numpy.nan: 
     447                    std = [True, str(std)] 
     448                else: 
     449                    std = [False, ''] 
     450                if lower is not None and lower is not numpy.nan: 
     451                    lower = [True, str(lower)] 
     452                else: 
     453                    lower = [True, '-inf'] 
     454                if upper is not None and upper is not numpy.nan: 
     455                    upper = [True, str(upper)] 
     456                else: 
     457                    upper = [True, 'inf'] 
     458                param_list = [bool(fittable), str(name), str(info), 
     459                              "+/-", std, lower, upper, str(units)] 
     460                p_map.append(param_list) 
     461        return p_map 
     462 
     463    def _convert_to_sasmodels(self): 
     464        """ 
     465        Convert parameters to a form usable by sasmodels converter 
     466 
     467        :return: None 
     468        """ 
     469        # Create conversion dictionary to send to sasmodels 
     470        self._old_first_model() 
     471        p = self.param_remap_to_sasmodels_convert(self.parameters) 
     472        structurefactor, params = convert.convert_model(self.structurecombobox, 
     473                                                        p, False, self.version) 
     474        formfactor, params = convert.convert_model(self.formfactorcombobox, 
     475                                                   params, False, self.version) 
     476        if len(self.str_parameters) > 0: 
     477            str_pars = self.param_remap_to_sasmodels_convert( 
     478                self.str_parameters, True) 
     479            formfactor, str_params = convert.convert_model( 
     480                self.formfactorcombobox, str_pars, False, self.version) 
     481            for key, value in str_params.iteritems(): 
     482                params[key] = value 
     483 
     484        if self.formfactorcombobox == 'SphericalSLDModel': 
     485            self.multi_factor += 1 
     486        self.formfactorcombobox = formfactor 
     487        self.structurecombobox = structurefactor 
     488        self.parameters = [] 
     489        self.parameters = self.param_remap_from_sasmodels_convert(params) 
    357490 
    358491    def _repr_helper(self, list, rep): 
    … …  
    682815 
    683816        attr = newdoc.createAttribute("version") 
    684         attr.nodeValue = '1.0' 
     817        import sasview 
     818        attr.nodeValue = sasview.__version__ 
     819        # attr.nodeValue = '1.0' 
    685820        top_element.setAttributeNode(attr) 
    686821 
    … …  
    8751010            raise RuntimeError, msg 
    8761011 
    877         if node.get('version') and node.get('version') == '1.0': 
     1012        if node.get('version'): 
     1013            # Get the version for model conversion purposes 
     1014            self.version = tuple(int(e) for e in 
     1015                                 str.split(node.get('version'), ".")) 
     1016            # The tuple must be at least 3 items long 
     1017            while len(self.version) < 3: 
     1018                ver_list = list(self.version) 
     1019                ver_list.append(0) 
     1020                self.version = tuple(ver_list) 
    8781021 
    8791022            # Get file name 
    … …  
    10331176        if self.cansas: 
    10341177            return self._read_cansas(path) 
    1035  
    1036     def _data2d_to_xml_doc(self, datainfo): 
    1037         """ 
    1038         Create an XML document to contain the content of a Data2D 
    1039  
    1040         :param datainfo: Data2D object 
    1041  
    1042         """ 
    1043         if not issubclass(datainfo.__class__, Data2D): 
    1044             raise RuntimeError, "The cansas writer expects a Data2D instance" 
    1045  
    1046         title = "cansas1d/%s" % self.version 
    1047         title += "http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" 
    1048         doc = xml.dom.minidom.Document() 
    1049         main_node = doc.createElement("SASroot") 
    1050         main_node.setAttribute("version", self.version) 
    1051         main_node.setAttribute("xmlns", "cansas1d/%s" % self.version) 
    1052         main_node.setAttribute("xmlns:xsi", 
    1053                                "http://www.w3.org/2001/XMLSchema-instance") 
    1054         main_node.setAttribute("xsi:schemaLocation", title) 
    1055  
    1056         doc.appendChild(main_node) 
    1057  
    1058         entry_node = doc.createElement("SASentry") 
    1059         main_node.appendChild(entry_node) 
    1060  
    1061         write_node(doc, entry_node, "Title", datainfo.title) 
    1062         if datainfo is not None: 
    1063             write_node(doc, entry_node, "data_class", 
    1064                        datainfo.__class__.__name__) 
    1065         for item in datainfo.run: 
    1066             runname = {} 
    1067             if item in datainfo.run_name and \ 
    1068                             len(str(datainfo.run_name[item])) > 1: 
    1069                 runname = {'name': datainfo.run_name[item]} 
    1070             write_node(doc, entry_node, "Run", item, runname) 
    1071         # Data info 
    1072         new_node = doc.createElement("SASdata") 
    1073         entry_node.appendChild(new_node) 
    1074         for item in LIST_OF_DATA_2D_ATTR: 
    1075             element = doc.createElement(item[0]) 
    1076             element.setAttribute(item[0], str(getattr(datainfo, item[1]))) 
    1077             new_node.appendChild(element) 
    1078  
    1079         for item in LIST_OF_DATA_2D_VALUES: 
    1080             root_node = doc.createElement(item[0]) 
    1081             new_node.appendChild(root_node) 
    1082             temp_list = getattr(datainfo, item[1]) 
    1083  
    1084             if temp_list is None or len(temp_list) == 0: 
    1085                 element = doc.createElement(item[0]) 
    1086                 element.appendChild(doc.createTextNode(str(temp_list))) 
    1087                 root_node.appendChild(element) 
    1088             else: 
    1089                 for value in temp_list: 
    1090                     element = doc.createElement(item[0]) 
    1091                     element.setAttribute(item[0], str(value)) 
    1092                     root_node.appendChild(element) 
    1093  
    1094         # Sample info 
    1095         sample = doc.createElement("SASsample") 
    1096         if datainfo.sample.name is not None: 
    1097             sample.setAttribute("name", str(datainfo.sample.name)) 
    1098         entry_node.appendChild(sample) 
    1099         write_node(doc, sample, "ID", str(datainfo.sample.ID)) 
    1100         write_node(doc, sample, "thickness", datainfo.sample.thickness, 
    1101                    {"unit": datainfo.sample.thickness_unit}) 
    1102         write_node(doc, sample, "transmission", datainfo.sample.transmission) 
    1103         write_node(doc, sample, "temperature", datainfo.sample.temperature, 
    1104                    {"unit": datainfo.sample.temperature_unit}) 
    1105  
    1106         for item in datainfo.sample.details: 
    1107             write_node(doc, sample, "details", item) 
    1108  
    1109         pos = doc.createElement("position") 
    1110         written = write_node(doc, pos, "x", datainfo.sample.position.x, 
    1111                              {"unit": datainfo.sample.position_unit}) 
    1112         written = written | write_node(doc, pos, "y", 
    1113                                        datainfo.sample.position.y, 
    1114                                        {"unit": datainfo.sample.position_unit}) 
    1115         written = written | write_node(doc, pos, "z", 
    1116                                        datainfo.sample.position.z, 
    1117                                        {"unit": datainfo.sample.position_unit}) 
    1118         if written: 
    1119             sample.appendChild(pos) 
    1120  
    1121         ori = doc.createElement("orientation") 
    1122         written = write_node(doc, ori, "roll", datainfo.sample.orientation.x, 
    1123                              {"unit": datainfo.sample.orientation_unit}) 
    1124         written = written | write_node(doc, ori, "pitch", 
    1125                                        datainfo.sample.orientation.y, 
    1126                                        {"unit": 
    1127                                             datainfo.sample.orientation_unit}) 
    1128         written = written | write_node(doc, ori, "yaw", 
    1129                                        datainfo.sample.orientation.z, 
    1130                                        {"unit": 
    1131                                             datainfo.sample.orientation_unit}) 
    1132         if written: 
    1133             sample.appendChild(ori) 
    1134  
    1135         # Instrument info 
    1136         instr = doc.createElement("SASinstrument") 
    1137         entry_node.appendChild(instr) 
    1138  
    1139         write_node(doc, instr, "name", datainfo.instrument) 
    1140  
    1141         #   Source 
    1142         source = doc.createElement("SASsource") 
    1143         if datainfo.source.name is not None: 
    1144             source.setAttribute("name", str(datainfo.source.name)) 
    1145         instr.appendChild(source) 
    1146  
    1147         write_node(doc, source, "radiation", datainfo.source.radiation) 
    1148         write_node(doc, source, "beam_shape", datainfo.source.beam_shape) 
    1149         size = doc.createElement("beam_size") 
    1150         if datainfo.source.beam_size_name is not None: 
    1151             size.setAttribute("name", str(datainfo.source.beam_size_name)) 
    1152         written = write_node(doc, size, "x", datainfo.source.beam_size.x, 
    1153                              {"unit": datainfo.source.beam_size_unit}) 
    1154         written = written | write_node(doc, size, "y", 
    1155                                        datainfo.source.beam_size.y, 
    1156                                        {"unit": datainfo.source.beam_size_unit}) 
    1157         written = written | write_node(doc, size, "z", 
    1158                                        datainfo.source.beam_size.z, 
    1159                                        {"unit": datainfo.source.beam_size_unit}) 
    1160         if written: 
    1161             source.appendChild(size) 
    1162  
    1163         write_node(doc, source, "wavelength", datainfo.source.wavelength, 
    1164                    {"unit": datainfo.source.wavelength_unit}) 
    1165         write_node(doc, source, "wavelength_min", 
    1166                    datainfo.source.wavelength_min, 
    1167                    {"unit": datainfo.source.wavelength_min_unit}) 
    1168         write_node(doc, source, "wavelength_max", 
    1169                    datainfo.source.wavelength_max, 
    1170                    {"unit": datainfo.source.wavelength_max_unit}) 
    1171         write_node(doc, source, "wavelength_spread", 
    1172                    datainfo.source.wavelength_spread, 
    1173                    {"unit": datainfo.source.wavelength_spread_unit}) 
    1174  
    1175         #   Collimation 
    1176         for item in datainfo.collimation: 
    1177             coll = doc.createElement("SAScollimation") 
    1178             if item.name is not None: 
    1179                 coll.setAttribute("name", str(item.name)) 
    1180             instr.appendChild(coll) 
    1181  
    1182             write_node(doc, coll, "length", item.length, 
    1183                        {"unit": item.length_unit}) 
    1184  
    1185             for apert in item.aperture: 
    1186                 ap = doc.createElement("aperture") 
    1187                 if apert.name is not None: 
    1188                     ap.setAttribute("name", str(apert.name)) 
    1189                 if apert.type is not None: 
    1190                     ap.setAttribute("type", str(apert.type)) 
    1191                 coll.appendChild(ap) 
    1192  
    1193                 write_node(doc, ap, "distance", apert.distance, 
    1194                            {"unit": apert.distance_unit}) 
    1195  
    1196                 size = doc.createElement("size") 
    1197                 if apert.size_name is not None: 
    1198                     size.setAttribute("name", str(apert.size_name)) 
    1199                 written = write_node(doc, size, "x", apert.size.x, 
    1200                                      {"unit": apert.size_unit}) 
    1201                 written = written | write_node(doc, size, "y", apert.size.y, 
    1202                                                {"unit": apert.size_unit}) 
    1203                 written = written | write_node(doc, size, "z", apert.size.z, 
    1204                                                {"unit": apert.size_unit}) 
    1205                 if written: 
    1206                     ap.appendChild(size) 
    1207  
    1208         #   Detectors 
    1209         for item in datainfo.detector: 
    1210             det = doc.createElement("SASdetector") 
    1211             written = write_node(doc, det, "name", item.name) 
    1212             written = written | write_node(doc, det, "SDD", item.distance, 
    1213                                            {"unit": item.distance_unit}) 
    1214             written = written | write_node(doc, det, "slit_length", 
    1215                                            item.slit_length, 
    1216                                            {"unit": item.slit_length_unit}) 
    1217             if written: 
    1218                 instr.appendChild(det) 
    1219  
    1220             off = doc.createElement("offset") 
    1221             written = write_node(doc, off, "x", item.offset.x, 
    1222                                  {"unit": item.offset_unit}) 
    1223             written = written | write_node(doc, off, "y", item.offset.y, 
    1224                                            {"unit": item.offset_unit}) 
    1225             written = written | write_node(doc, off, "z", item.offset.z, 
    1226                                            {"unit": item.offset_unit}) 
    1227             if written: 
    1228                 det.appendChild(off) 
    1229  
    1230             center = doc.createElement("beam_center") 
    1231             written = write_node(doc, center, "x", item.beam_center.x, 
    1232                                  {"unit": item.beam_center_unit}) 
    1233             written = written | write_node(doc, center, "y", 
    1234                                            item.beam_center.y, 
    1235                                            {"unit": item.beam_center_unit}) 
    1236             written = written | write_node(doc, center, "z", 
    1237                                            item.beam_center.z, 
    1238                                            {"unit": item.beam_center_unit}) 
    1239             if written: 
    1240                 det.appendChild(center) 
    1241  
    1242             pix = doc.createElement("pixel_size") 
    1243             written = write_node(doc, pix, "x", item.pixel_size.x, 
    1244                                  {"unit": item.pixel_size_unit}) 
    1245             written = written | write_node(doc, pix, "y", item.pixel_size.y, 
    1246                                            {"unit": item.pixel_size_unit}) 
    1247             written = written | write_node(doc, pix, "z", item.pixel_size.z, 
    1248                                            {"unit": item.pixel_size_unit}) 
    1249             if written: 
    1250                 det.appendChild(pix) 
    1251  
    1252             ori = doc.createElement("orientation") 
    1253             written = write_node(doc, ori, "roll", item.orientation.x, 
    1254                                  {"unit": item.orientation_unit}) 
    1255             written = written | write_node(doc, ori, "pitch", 
    1256                                            item.orientation.y, 
    1257                                            {"unit": item.orientation_unit}) 
    1258             written = written | write_node(doc, ori, "yaw", item.orientation.z, 
    1259                                            {"unit": item.orientation_unit}) 
    1260             if written: 
    1261                 det.appendChild(ori) 
    1262  
    1263         # Processes info 
    1264         for item in datainfo.process: 
    1265             node = doc.createElement("SASprocess") 
    1266             entry_node.appendChild(node) 
    1267  
    1268             write_node(doc, node, "name", item.name) 
    1269             write_node(doc, node, "date", item.date) 
    1270             write_node(doc, node, "description", item.description) 
    1271             for term in item.term: 
    1272                 value = term['value'] 
    1273                 del term['value'] 
    1274                 write_node(doc, node, "term", value, term) 
    1275             for note in item.notes: 
    1276                 write_node(doc, node, "SASprocessnote", note) 
    1277         # Return the document, and the SASentry node associated with 
    1278         # the data we just wrote 
    1279         return doc, entry_node 
    12801178 
    12811179    def _parse_state(self, entry): 
    … …  
    13541252        """ 
    13551253        node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS}) 
    1356         if not node or node[0].text.lstrip().rstrip() != "Data2D": 
    1357             return_value, _ = self._parse_entry(dom) 
    1358             numpy.trim_zeros(return_value.x) 
    1359             numpy.trim_zeros(return_value.y) 
    1360             numpy.trim_zeros(return_value.dy) 
    1361             size_dx = return_value.dx.size 
    1362             size_dxl = return_value.dxl.size 
    1363             size_dxw = return_value.dxw.size 
    1364             if size_dxl == 0 and size_dxw == 0: 
    1365                 return_value.dxl = None 
    1366                 return_value.dxw = None 
    1367                 numpy.trim_zeros(return_value.dx) 
    1368             elif size_dx == 0: 
    1369                 return_value.dx = None 
    1370                 size_dx = size_dxl 
    1371                 numpy.trim_zeros(return_value.dxl) 
    1372                 numpy.trim_zeros(return_value.dxw) 
    1373  
    1374             return return_value, _ 
    1375  
    1376         # Parse 2D 
    1377         data_info = Data2D() 
    1378  
    1379         # Look up title 
    1380         self._store_content('ns:Title', dom, 'title', data_info) 
    1381  
    1382         # Look up run number 
    1383         nodes = dom.xpath('ns:Run', namespaces={'ns': CANSAS_NS}) 
    1384         for item in nodes: 
    1385             if item.text is not None: 
    1386                 value = item.text.strip() 
    1387                 if len(value) > 0: 
    1388                     data_info.run.append(value) 
    1389                     if item.get('name') is not None: 
    1390                         data_info.run_name[value] = item.get('name') 
    1391  
    1392         # Look up instrument name 
    1393         self._store_content('ns:SASinstrument/ns:name', dom, 
    1394                             'instrument', data_info) 
    1395  
    1396         # Notes 
    1397         note_list = dom.xpath('ns:SASnote', namespaces={'ns': CANSAS_NS}) 
    1398         for note in note_list: 
    1399             try: 
    1400                 if note.text is not None: 
    1401                     note_value = note.text.strip() 
    1402                     if len(note_value) > 0: 
    1403                         data_info.notes.append(note_value) 
    1404             except Exception: 
    1405                 err_mess = "cansas_reader.read: error processing entry notes\n" 
    1406                 err_mess += "  %s" % sys.exc_value 
    1407                 self.errors.append(err_mess) 
    1408                 logging.error(err_mess) 
    1409  
    1410         # Sample info ################### 
    1411         entry = get_content('ns:SASsample', dom) 
    1412         if entry is not None: 
    1413             data_info.sample.name = entry.get('name') 
    1414  
    1415         self._store_content('ns:SASsample/ns:ID', dom, 'ID', data_info.sample) 
    1416         self._store_float('ns:SASsample/ns:thickness', dom, 'thickness', 
    1417                           data_info.sample) 
    1418         self._store_float('ns:SASsample/ns:transmission', dom, 'transmission', 
    1419                           data_info.sample) 
    1420         self._store_float('ns:SASsample/ns:temperature', dom, 'temperature', 
    1421                           data_info.sample) 
    1422  
    1423         nodes = dom.xpath('ns:SASsample/ns:details', 
    1424                           namespaces={'ns': CANSAS_NS}) 
    1425         for item in nodes: 
    1426             try: 
    1427                 if item.text is not None: 
    1428                     detail_value = item.text.strip() 
    1429                     if len(detail_value) > 0: 
    1430                         data_info.sample.details.append(detail_value) 
    1431             except Exception: 
    1432                 err_mess = "cansas_reader.read: error processing entry notes\n" 
    1433                 err_mess += "  %s" % sys.exc_value 
    1434                 self.errors.append(err_mess) 
    1435                 logging.error(err_mess) 
    1436  
    1437         # Position (as a vector) 
    1438         self._store_float('ns:SASsample/ns:position/ns:x', dom, 'position.x', 
    1439                           data_info.sample) 
    1440         self._store_float('ns:SASsample/ns:position/ns:y', dom, 'position.y', 
    1441                           data_info.sample) 
    1442         self._store_float('ns:SASsample/ns:position/ns:z', dom, 'position.z', 
    1443                           data_info.sample) 
    1444  
    1445         # Orientation (as a vector) 
    1446         self._store_float('ns:SASsample/ns:orientation/ns:roll', 
    1447                           dom, 'orientation.x', data_info.sample) 
    1448         self._store_float('ns:SASsample/ns:orientation/ns:pitch', 
    1449                           dom, 'orientation.y', data_info.sample) 
    1450         self._store_float('ns:SASsample/ns:orientation/ns:yaw', 
    1451                           dom, 'orientation.z', data_info.sample) 
    1452  
    1453         # Source info ################### 
    1454         entry = get_content('ns:SASinstrument/ns:SASsource', dom) 
    1455         if entry is not None: 
    1456             data_info.source.name = entry.get('name') 
    1457  
    1458         self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation', 
    1459                             dom, 'radiation', data_info.source) 
    1460         self._store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape', 
    1461                             dom, 'beam_shape', data_info.source) 
    1462         self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength', 
    1463                           dom, 'wavelength', data_info.source) 
    1464         self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min', 
    1465                           dom, 'wavelength_min', data_info.source) 
    1466         self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max', 
    1467                           dom, 'wavelength_max', data_info.source) 
    1468         self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread', 
    1469                           dom, 'wavelength_spread', data_info.source) 
    1470  
    1471         # Beam size (as a vector) 
    1472         entry = get_content('ns:SASinstrument/ns:SASsource/ns:beam_size', dom) 
    1473         if entry is not None: 
    1474             data_info.source.beam_size_name = entry.get('name') 
    1475  
    1476         self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x', 
    1477                           dom, 'beam_size.x', data_info.source) 
    1478         self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y', 
    1479                           dom, 'beam_size.y', data_info.source) 
    1480         self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z', 
    1481                           dom, 'beam_size.z', data_info.source) 
    1482  
    1483         # Collimation info ################### 
    1484         nodes = dom.xpath('ns:SASinstrument/ns:SAScollimation', 
    1485                           namespaces={'ns': CANSAS_NS}) 
    1486         for item in nodes: 
    1487             collim = Collimation() 
    1488             if item.get('name') is not None: 
    1489                 collim.name = item.get('name') 
    1490             self._store_float('ns:length', item, 'length', collim) 
    1491  
    1492             # Look for apertures 
    1493             apert_list = item.xpath('ns:aperture', 
    1494                                     namespaces={'ns': CANSAS_NS}) 
    1495             for apert in apert_list: 
    1496                 aperture = Aperture() 
    1497  
    1498                 # Get the name and type of the aperture 
    1499                 aperture.name = apert.get('name') 
    1500                 aperture.type = apert.get('type') 
    1501  
    1502                 self._store_float('ns:distance', apert, 'distance', aperture) 
    1503  
    1504                 entry = get_content('ns:size', apert) 
    1505                 if entry is not None: 
    1506                     aperture.size_name = entry.get('name') 
    1507  
    1508                 self._store_float('ns:size/ns:x', apert, 'size.x', aperture) 
    1509                 self._store_float('ns:size/ns:y', apert, 'size.y', aperture) 
    1510                 self._store_float('ns:size/ns:z', apert, 'size.z', aperture) 
    1511  
    1512                 collim.aperture.append(aperture) 
    1513  
    1514             data_info.collimation.append(collim) 
    1515  
    1516         # Detector info ###################### 
    1517         nodes = dom.xpath('ns:SASinstrument/ns:SASdetector', 
    1518                           namespaces={'ns': CANSAS_NS}) 
    1519         for item in nodes: 
    1520  
    1521             detector = Detector() 
    1522  
    1523             self._store_content('ns:name', item, 'name', detector) 
    1524             self._store_float('ns:SDD', item, 'distance', detector) 
    1525  
    1526             # Detector offset (as a vector) 
    1527             self._store_float('ns:offset/ns:x', item, 'offset.x', detector) 
    1528             self._store_float('ns:offset/ns:y', item, 'offset.y', detector) 
    1529             self._store_float('ns:offset/ns:z', item, 'offset.z', detector) 
    1530  
    1531             # Detector orientation (as a vector) 
    1532             self._store_float('ns:orientation/ns:roll', item, 
    1533                               'orientation.x', detector) 
    1534             self._store_float('ns:orientation/ns:pitch', item, 
    1535                               'orientation.y', detector) 
    1536             self._store_float('ns:orientation/ns:yaw', item, 
    1537                               'orientation.z', detector) 
    1538  
    1539             # Beam center (as a vector) 
    1540             self._store_float('ns:beam_center/ns:x', item, 
    1541                               'beam_center.x', detector) 
    1542             self._store_float('ns:beam_center/ns:y', item, 
    1543                               'beam_center.y', detector) 
    1544             self._store_float('ns:beam_center/ns:z', item, 
    1545                               'beam_center.z', detector) 
    1546  
    1547             # Pixel size (as a vector) 
    1548             self._store_float('ns:pixel_size/ns:x', item, 
    1549                               'pixel_size.x', detector) 
    1550             self._store_float('ns:pixel_size/ns:y', item, 
    1551                               'pixel_size.y', detector) 
    1552             self._store_float('ns:pixel_size/ns:z', item, 
    1553                               'pixel_size.z', detector) 
    1554  
    1555             self._store_float('ns:slit_length', item, 'slit_length', detector) 
    1556  
    1557             data_info.detector.append(detector) 
    1558  
    1559         # Processes info ###################### 
    1560         nodes = dom.xpath('ns:SASprocess', namespaces={'ns': CANSAS_NS}) 
    1561         for item in nodes: 
    1562             process = Process() 
    1563             self._store_content('ns:name', item, 'name', process) 
    1564             self._store_content('ns:date', item, 'date', process) 
    1565             self._store_content('ns:description', item, 'description', process) 
    1566  
    1567             term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS}) 
    1568             for term in term_list: 
    1569                 try: 
    1570                     term_attr = {} 
    1571                     for attr in term.keys(): 
    1572                         term_attr[attr] = term.get(attr).strip() 
    1573                     if term.text is not None: 
    1574                         term_attr['value'] = term.text.strip() 
    1575                         process.term.append(term_attr) 
    1576                 except: 
    1577                     err_mess = "cansas_reader.read: error processing " 
    1578                     err_mess += "entry notes\n  %s" % sys.exc_value 
    1579                     self.errors.append(err_mess) 
    1580                     logging.error(err_mess) 
    1581  
    1582             note_list = item.xpath('ns:SASprocessnote', 
    1583                                    namespaces={'ns': CANSAS_NS}) 
    1584             for note in note_list: 
    1585                 if note.text is not None: 
    1586                     process.notes.append(note.text.strip()) 
    1587  
    1588             data_info.process.append(process) 
    1589  
    1590         # Data info ###################### 
    1591         nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS}) 
    1592         if len(nodes) > 1: 
    1593             raise RuntimeError, "CanSAS reader is not compatible with" + \ 
    1594                                 " multiple SASdata entries" 
    1595  
    1596         for entry in nodes: 
    1597             for item in LIST_OF_DATA_2D_ATTR: 
    1598                 # get node 
    1599                 node = get_content('ns:%s' % item[0], entry) 
    1600                 setattr(data_info, item[1], parse_entry_helper(node, item)) 
    1601  
    1602             for item in LIST_OF_DATA_2D_VALUES: 
    1603                 field = get_content('ns:%s' % item[0], entry) 
    1604                 value_list = [] 
    1605                 if field is not None: 
    1606                     value_list = \ 
    1607                         [parse_entry_helper(node, item) for node in field] 
    1608                 if len(value_list) < 2: 
    1609                     setattr(data_info, item[0], None) 
    1610                 else: 
    1611                     setattr(data_info, item[0], numpy.array(value_list)) 
    1612  
    1613         return data_info 
     1254        return_value, _ = self._parse_entry(dom) 
     1255        return return_value, _ 
    16141256 
    16151257    def _read_cansas(self, path): 
    … …  
    16921334                        name = original_fname 
    16931335                    state.data.group_id = name 
     1336                    state.version = fitstate.version 
    16941337                    # store state in fitting 
    16951338                    self.call_back(state=state, 
    … …  
    17451388            state.data.run_name[0] = state.data.name 
    17461389 
    1747         if issubclass(state.data.__class__, 
    1748                       sas.sascalc.dataloader.data_info.Data1D): 
    1749             data = state.data 
    1750             doc, sasentry = self._to_xml_doc(data) 
    1751         else: 
    1752             data = state.data 
    1753             doc, sasentry = self._data2d_to_xml_doc(data) 
     1390        data = state.data 
     1391        doc, sasentry = self._to_xml_doc(data) 
    17541392 
    17551393        if state is not None: 

  • src/sas/sasgui/perspectives/invariant/invariant_state.py

    rcb93b40 rdb5294e  
    423423                    for item in DEFAULT_STATE: 
    424424                        input_field = get_content('ns:%s' % item, entry) 
    425                         val = str(input_field.text.strip()) 
     425                        if input_field.text is not None: 
     426                            val = str(input_field.text.strip()) 
     427                        else: 
     428                            val = '' 
    426429                        if input_field is not None: 
    427430                            temp_state[item] = val 
    … …  
    433436                for item in DEFAULT_STATE: 
    434437                    input_field = get_content('ns:%s' % item, entry) 
    435                     val = str(input_field.text.strip()) 
     438                    if input_field.text is not None: 
     439                        val = str(input_field.text.strip()) 
     440                    else: 
     441                        val = '' 
    436442                    if input_field is not None: 
    437443                        self.set_saved_state(name=item, value=val) 

  • src/sas/sasgui/perspectives/fitting/fitting.py

    r73cbeec re92a352  
    225225 
    226226        self.id_edit = wx.NewId() 
    227         editmodel_help = "Edit customized model sample file" 
    228227        self.menu1.AppendMenu(self.id_edit, "Plugin Model Operations", 
    229                               self.edit_model_menu, editmodel_help) 
     228                              self.edit_model_menu) 
    230229        #create  menubar items 
    231230        return [(self.menu1, self.sub_menu)] 
    … …  
    260259            self.update_custom_combo() 
    261260            if os.path.isfile(p_path): 
    262                 msg = "Sorry! Could not be able to delete the default " 
    263                 msg += "custom model... \n" 
     261                msg = "Sorry! unable to delete the default " 
     262                msg += "plugin model... \n" 
    264263                msg += "Please manually remove the files (.py, .pyc) " 
    265264                msg += "in the 'plugin_models' folder \n" 
    … …  
    274273                    if item.GetLabel() == label: 
    275274                        self.edit_menu.DeleteItem(item) 
    276                         msg = "The custom model, %s, has been deleted." % label 
     275                        msg = "The plugin model, %s, has been deleted." % label 
    277276                        evt = StatusEvent(status=msg, type='stop', info='info') 
    278277                        wx.PostEvent(self.parent, evt) 
    … …  
    331330            temp = self.fit_panel.reset_pmodel_list() 
    332331            if temp: 
    333                 # Set the new custom model list for all fit pages 
     332                # Set the new plugin model list for all fit pages 
    334333                for uid, page in self.fit_panel.opened_pages.iteritems(): 
    335334                    if hasattr(page, "formfactorbox"): 
Note: See TracChangeset for help on using the changeset viewer.