Changeset 2510b9b in sasview for src


Ignore:
Timestamp:
Feb 7, 2017 2:05:10 PM (7 years ago)
Author:
GitHub <noreply@…>
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:
a99a4045, 1a8e13f0, b61bd57, 03137f1, 18da4a8, 1e13b53
Parents:
2ab9c432 (diff), bcabf4e (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.
git-author:
Paul Kienzle <pkienzle@…> (02/07/17 14:05:10)
git-committer:
GitHub <noreply@…> (02/07/17 14:05:10)
Message:

Merge pull request #30 from SasView?/ticket-827

Fixes #795, #819, #827, #847

Location:
src/sas
Files:
1 added
21 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    r0639476 rbcabf4e  
    2020import inspect 
    2121# For saving individual sections of data 
    22 from sas.sascalc.dataloader.data_info import Data1D, DataInfo, plottable_1D 
    23 from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, Detector, Process, Aperture 
    24 from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable as combine_data 
     22from sas.sascalc.dataloader.data_info import Data1D, Data2D, DataInfo, \ 
     23    plottable_1D, plottable_2D 
     24from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, \ 
     25    Detector, Process, Aperture 
     26from sas.sascalc.dataloader.data_info import \ 
     27    combine_data_info_with_plottable as combine_data 
    2528import sas.sascalc.dataloader.readers.xml_reader as xml_reader 
    2629from sas.sascalc.dataloader.readers.xml_reader import XMLreader 
    … …  
    5659        The CanSAS reader requires PyXML 0.8.4 or later. 
    5760    """ 
    58     ## CanSAS version - defaults to version 1.0 
     61    # CanSAS version - defaults to version 1.0 
    5962    cansas_version = "1.0" 
    6063    base_ns = "{cansas1d/1.0}" 
    … …  
    6366    invalid = True 
    6467    frm = "" 
    65     ## Log messages and errors 
     68    # Log messages and errors 
    6669    logging = None 
    6770    errors = set() 
    68     ## Namespace hierarchy for current xml_file object 
     71    # Namespace hierarchy for current xml_file object 
    6972    names = None 
    7073    ns_list = None 
    71     ## Temporary storage location for loading multiple data sets in a single file 
     74    # Temporary storage location for loading multiple data sets in a single file 
    7275    current_datainfo = None 
    7376    current_dataset = None 
    7477    current_data1d = None 
    7578    data = None 
    76     ## List of data1D objects to be sent back to SasView 
     79    # List of data1D objects to be sent back to SasView 
    7780    output = None 
    78     ## Wildcards 
     81    # Wildcards 
    7982    type = ["XML files (*.xml)|*.xml", "SasView Save Files (*.svs)|*.svs"] 
    80     ## List of allowed extensions 
     83    # List of allowed extensions 
    8184    ext = ['.xml', '.XML', '.svs', '.SVS'] 
    82     ## Flag to bypass extension check 
     85    # Flag to bypass extension check 
    8386    allow_all = True 
    8487 
    … …  
    220223                self.parent_class = tagname_original 
    221224                if tagname == 'SASdata': 
    222                     self._initialize_new_data_set() 
    223                 ## Recursion step to access data within the group 
     225                    self._initialize_new_data_set(node) 
     226                    if isinstance(self.current_dataset, plottable_2D): 
     227                        x_bins = attr.get("x_bins", "") 
     228                        y_bins = attr.get("y_bins", "") 
     229                        if x_bins is not "" and y_bins is not "": 
     230                            self.current_dataset.shape = (x_bins, y_bins) 
     231                        else: 
     232                            self.current_dataset.shape = () 
     233                # Recursion step to access data within the group 
    224234                self._parse_entry(node, True) 
    225235                if tagname == "SASsample": 
    … …  
    234244                self.add_intermediate() 
    235245            else: 
    236                 data_point, unit = self._get_node_value(node, tagname) 
    237  
    238                 ## If this is a dataset, store the data appropriately 
     246                if isinstance(self.current_dataset, plottable_2D): 
     247                    data_point = node.text 
     248                    unit = attr.get('unit', '') 
     249                else: 
     250                    data_point, unit = self._get_node_value(node, tagname) 
     251 
     252                # If this is a dataset, store the data appropriately 
    239253                if tagname == 'Run': 
    240254                    self.current_datainfo.run_name[data_point] = name 
    … …  
    245259                    self.current_datainfo.notes.append(data_point) 
    246260 
    247                 ## I and Q Data 
    248                 elif tagname == 'I': 
     261                # I and Q - 1D data 
     262                elif tagname == 'I' and isinstance(self.current_dataset, plottable_1D): 
    249263                    self.current_dataset.yaxis("Intensity", unit) 
    250264                    self.current_dataset.y = np.append(self.current_dataset.y, data_point) 
    251                 elif tagname == 'Idev': 
     265                elif tagname == 'Idev' and isinstance(self.current_dataset, plottable_1D): 
    252266                    self.current_dataset.dy = np.append(self.current_dataset.dy, data_point) 
    253267                elif tagname == 'Q': 
    … …  
    265279                    pass 
    266280 
    267                 ## Sample Information 
     281                # I and Qx, Qy - 2D data 
     282                elif tagname == 'I' and isinstance(self.current_dataset, plottable_2D): 
     283                    self.current_dataset.yaxis("Intensity", unit) 
     284                    self.current_dataset.data = np.fromstring(data_point, dtype=float, sep=",") 
     285                elif tagname == 'Idev' and isinstance(self.current_dataset, plottable_2D): 
     286                    self.current_dataset.err_data = np.fromstring(data_point, dtype=float, sep=",") 
     287                elif tagname == 'Qx': 
     288                    self.current_dataset.xaxis("Qx", unit) 
     289                    self.current_dataset.qx_data = np.fromstring(data_point, dtype=float, sep=",") 
     290                elif tagname == 'Qy': 
     291                    self.current_dataset.yaxis("Qy", unit) 
     292                    self.current_dataset.qy_data = np.fromstring(data_point, dtype=float, sep=",") 
     293                elif tagname == 'Qxdev': 
     294                    self.current_dataset.xaxis("Qxdev", unit) 
     295                    self.current_dataset.dqx_data = np.fromstring(data_point, dtype=float, sep=",") 
     296                elif tagname == 'Qydev': 
     297                    self.current_dataset.yaxis("Qydev", unit) 
     298                    self.current_dataset.dqy_data = np.fromstring(data_point, dtype=float, sep=",") 
     299                elif tagname == 'Mask': 
     300                    inter = [item == "1" for item in data_point.split(",")] 
     301                    self.current_dataset.mask = np.asarray(inter, dtype=bool) 
     302 
     303                # Sample Information 
    268304                elif tagname == 'ID' and self.parent_class == 'SASsample': 
    269305                    self.current_datainfo.sample.ID = data_point 
    … …  
    299335                    self.current_datainfo.sample.orientation_unit = unit 
    300336 
    301                 ## Instrumental Information 
     337                # Instrumental Information 
    302338                elif tagname == 'name' and self.parent_class == 'SASinstrument': 
    303339                    self.current_datainfo.instrument = data_point 
    304                 ## Detector Information 
     340                # Detector Information 
    305341                elif tagname == 'name' and self.parent_class == 'SASdetector': 
    306342                    self.detector.name = data_point 
    … …  
    347383                    self.detector.orientation.z = data_point 
    348384                    self.detector.orientation_unit = unit 
    349                 ## Collimation and Aperture 
     385                # Collimation and Aperture 
    350386                elif tagname == 'length' and self.parent_class == 'SAScollimation': 
    351387                    self.collimation.length = data_point 
    … …  
    366402                    self.collimation.size_unit = unit 
    367403 
    368                 ## Process Information 
     404                # Process Information 
    369405                elif tagname == 'name' and self.parent_class == 'SASprocess': 
    370406                    self.process.name = data_point 
    … …  
    386422                    self.process.term.append(dic) 
    387423 
    388                 ## Transmission Spectrum 
     424                # Transmission Spectrum 
    389425                elif tagname == 'T' and self.parent_class == 'Tdata': 
    390426                    self.transspectrum.transmission = np.append(self.transspectrum.transmission, data_point) 
    … …  
    397433                    self.transspectrum.wavelength_unit = unit 
    398434 
    399                 ## Source Information 
     435                # Source Information 
    400436                elif tagname == 'wavelength' and (self.parent_class == 'SASsource' or self.parent_class == 'SASData'): 
    401437                    self.current_datainfo.source.wavelength = data_point 
    … …  
    424460                    self.current_datainfo.source.beam_shape = data_point 
    425461 
    426                 ## Everything else goes in meta_data 
     462                # Everything else goes in meta_data 
    427463                else: 
    428464                    new_key = self._create_unique_key(self.current_datainfo.meta_data, tagname) 
    … …  
    438474            self.add_data_set() 
    439475            empty = None 
    440             if self.output[0].dx is not None: 
    441                 self.output[0].dxl = np.empty(0) 
    442                 self.output[0].dxw = np.empty(0) 
    443             else: 
    444                 self.output[0].dx = np.empty(0) 
    445476            return self.output[0], empty 
    446477 
    … …  
    514545        self.current_datainfo = DataInfo() 
    515546 
    516     def _initialize_new_data_set(self, parent_list=None): 
     547    def _initialize_new_data_set(self, node=None): 
    517548        """ 
    518549        A private class method to generate a new 1D data object. 
    519550        Outside methods should call add_data_set() to be sure any existing data is stored properly. 
    520551 
    521         :param parent_list: List of names of parent elements 
    522         """ 
    523  
    524         if parent_list is None: 
    525             parent_list = [] 
     552        :param node: XML node to determine if 1D or 2D data 
     553        """ 
    526554        x = np.array(0) 
    527555        y = np.array(0) 
     556        for child in node: 
     557            if child.tag.replace(self.base_ns, "") == "Idata": 
     558                for i_child in child: 
     559                    if i_child.tag.replace(self.base_ns, "") == "Qx": 
     560                        self.current_dataset = plottable_2D() 
     561                        return 
    528562        self.current_dataset = plottable_1D(x, y) 
    529563 
    … …  
    560594        """ 
    561595 
    562         ## Append errors to dataset and reset class errors 
     596        # Append errors to dataset and reset class errors 
    563597        self.current_datainfo.errors = set() 
    564598        for error in self.errors: 
    … …  
    566600        self.errors.clear() 
    567601 
    568         ## Combine all plottables with datainfo and append each to output 
    569         ## Type cast data arrays to float64 and find min/max as appropriate 
     602        # Combine all plottables with datainfo and append each to output 
     603        # Type cast data arrays to float64 and find min/max as appropriate 
    570604        for dataset in self.data: 
    571             if dataset.x is not None: 
    572                 dataset.x = np.delete(dataset.x, [0]) 
    573                 dataset.x = dataset.x.astype(np.float64) 
    574                 dataset.xmin = np.min(dataset.x) 
    575                 dataset.xmax = np.max(dataset.x) 
    576             if dataset.y is not None: 
    577                 dataset.y = np.delete(dataset.y, [0]) 
    578                 dataset.y = dataset.y.astype(np.float64) 
    579                 dataset.ymin = np.min(dataset.y) 
    580                 dataset.ymax = np.max(dataset.y) 
    581             if dataset.dx is not None: 
    582                 dataset.dx = np.delete(dataset.dx, [0]) 
    583                 dataset.dx = dataset.dx.astype(np.float64) 
    584             if dataset.dxl is not None: 
    585                 dataset.dxl = np.delete(dataset.dxl, [0]) 
    586                 dataset.dxl = dataset.dxl.astype(np.float64) 
    587             if dataset.dxw is not None: 
    588                 dataset.dxw = np.delete(dataset.dxw, [0]) 
    589                 dataset.dxw = dataset.dxw.astype(np.float64) 
    590             if dataset.dy is not None: 
    591                 dataset.dy = np.delete(dataset.dy, [0]) 
    592                 dataset.dy = dataset.dy.astype(np.float64) 
    593             np.trim_zeros(dataset.x) 
    594             np.trim_zeros(dataset.y) 
    595             np.trim_zeros(dataset.dy) 
     605            if isinstance(dataset, plottable_1D): 
     606                if dataset.x is not None: 
     607                    dataset.x = np.delete(dataset.x, [0]) 
     608                    dataset.x = dataset.x.astype(np.float64) 
     609                    dataset.xmin = np.min(dataset.x) 
     610                    dataset.xmax = np.max(dataset.x) 
     611                if dataset.y is not None: 
     612                    dataset.y = np.delete(dataset.y, [0]) 
     613                    dataset.y = dataset.y.astype(np.float64) 
     614                    dataset.ymin = np.min(dataset.y) 
     615                    dataset.ymax = np.max(dataset.y) 
     616                if dataset.dx is not None: 
     617                    dataset.dx = np.delete(dataset.dx, [0]) 
     618                    dataset.dx = dataset.dx.astype(np.float64) 
     619                if dataset.dxl is not None: 
     620                    dataset.dxl = np.delete(dataset.dxl, [0]) 
     621                    dataset.dxl = dataset.dxl.astype(np.float64) 
     622                if dataset.dxw is not None: 
     623                    dataset.dxw = np.delete(dataset.dxw, [0]) 
     624                    dataset.dxw = dataset.dxw.astype(np.float64) 
     625                if dataset.dy is not None: 
     626                    dataset.dy = np.delete(dataset.dy, [0]) 
     627                    dataset.dy = dataset.dy.astype(np.float64) 
     628                np.trim_zeros(dataset.x) 
     629                np.trim_zeros(dataset.y) 
     630                np.trim_zeros(dataset.dy) 
     631            elif isinstance(dataset, plottable_2D): 
     632                dataset.data = dataset.data.astype(np.float64) 
     633                dataset.qx_data = dataset.qx_data.astype(np.float64) 
     634                dataset.xmin = np.min(dataset.qx_data) 
     635                dataset.xmax = np.max(dataset.qx_data) 
     636                dataset.qy_data = dataset.qy_data.astype(np.float64) 
     637                dataset.ymin = np.min(dataset.qy_data) 
     638                dataset.ymax = np.max(dataset.qy_data) 
     639                dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data 
     640                                         + dataset.qy_data * dataset.qy_data) 
     641                if dataset.err_data is not None: 
     642                    dataset.err_data = dataset.err_data.astype(np.float64) 
     643                if dataset.dqx_data is not None: 
     644                    dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
     645                if dataset.dqy_data is not None: 
     646                    dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
     647                if dataset.mask is not None: 
     648                    dataset.mask = dataset.mask.astype(dtype=bool) 
     649 
     650                if len(dataset.shape) == 2: 
     651                    n_rows, n_cols = dataset.shape 
     652                    dataset.y_bins = dataset.qy_data[0::int(n_cols)] 
     653                    dataset.x_bins = dataset.qx_data[:int(n_cols)] 
     654                    dataset.data = dataset.data.flatten() 
     655                else: 
     656                    dataset.y_bins = [] 
     657                    dataset.x_bins = [] 
     658                    dataset.data = dataset.data.flatten() 
     659 
    596660            final_dataset = combine_data(dataset, self.current_datainfo) 
    597661            self.output.append(final_dataset) 
    … …  
    693757                        and local_unit.lower() != "none": 
    694758                    if HAS_CONVERTER == True: 
    695                         ## Check local units - bad units raise KeyError 
     759                        # Check local units - bad units raise KeyError 
    696760                        data_conv_q = Converter(local_unit) 
    697761                        value_unit = default_unit 
    … …  
    740804        A method to check all resolution data sets are the same size as I and Q 
    741805        """ 
    742         dql_exists = False 
    743         dqw_exists = False 
    744         dq_exists = False 
    745         di_exists = False 
    746         if self.current_dataset.dxl is not None: 
    747             dql_exists = True 
    748         if self.current_dataset.dxw is not None: 
    749             dqw_exists = True 
    750         if self.current_dataset.dx is not None: 
    751             dq_exists = True 
    752         if self.current_dataset.dy is not None: 
    753             di_exists = True 
    754         if dqw_exists and not dql_exists: 
    755             array_size = self.current_dataset.dxw.size - 1 
    756             self.current_dataset.dxl = np.append(self.current_dataset.dxl, np.zeros([array_size])) 
    757         elif dql_exists and not dqw_exists: 
    758             array_size = self.current_dataset.dxl.size - 1 
    759             self.current_dataset.dxw = np.append(self.current_dataset.dxw, np.zeros([array_size])) 
    760         elif not dql_exists and not dqw_exists and not dq_exists: 
    761             array_size = self.current_dataset.x.size - 1 
    762             self.current_dataset.dx = np.append(self.current_dataset.dx, np.zeros([array_size])) 
    763         if not di_exists: 
    764             array_size = self.current_dataset.y.size - 1 
    765             self.current_dataset.dy = np.append(self.current_dataset.dy, np.zeros([array_size])) 
    766  
     806        if isinstance(self.current_dataset, plottable_1D): 
     807            dql_exists = False 
     808            dqw_exists = False 
     809            dq_exists = False 
     810            di_exists = False 
     811            if self.current_dataset.dxl is not None: 
     812                dql_exists = True 
     813            if self.current_dataset.dxw is not None: 
     814                dqw_exists = True 
     815            if self.current_dataset.dx is not None: 
     816                dq_exists = True 
     817            if self.current_dataset.dy is not None: 
     818                di_exists = True 
     819            if dqw_exists and not dql_exists: 
     820                array_size = self.current_dataset.dxw.size - 1 
     821                self.current_dataset.dxl = np.append(self.current_dataset.dxl, 
     822                                                     np.zeros([array_size])) 
     823            elif dql_exists and not dqw_exists: 
     824                array_size = self.current_dataset.dxl.size - 1 
     825                self.current_dataset.dxw = np.append(self.current_dataset.dxw, 
     826                                                     np.zeros([array_size])) 
     827            elif not dql_exists and not dqw_exists and not dq_exists: 
     828                array_size = self.current_dataset.x.size - 1 
     829                self.current_dataset.dx = np.append(self.current_dataset.dx, 
     830                                                    np.zeros([array_size])) 
     831            if not di_exists: 
     832                array_size = self.current_dataset.y.size - 1 
     833                self.current_dataset.dy = np.append(self.current_dataset.dy, 
     834                                                    np.zeros([array_size])) 
     835        elif isinstance(self.current_dataset, plottable_2D): 
     836            dqx_exists = False 
     837            dqy_exists = False 
     838            di_exists = False 
     839            mask_exists = False 
     840            if self.current_dataset.dqx_data is not None: 
     841                dqx_exists = True 
     842            if self.current_dataset.dqy_data is not None: 
     843                dqy_exists = True 
     844            if self.current_dataset.err_data is not None: 
     845                di_exists = True 
     846            if self.current_dataset.mask is not None: 
     847                mask_exists = True 
     848            if not dqy_exists: 
     849                array_size = self.current_dataset.qy_data.size - 1 
     850                self.current_dataset.dqy_data = np.append( 
     851                    self.current_dataset.dqy_data, np.zeros([array_size])) 
     852            if not dqx_exists: 
     853                array_size = self.current_dataset.qx_data.size - 1 
     854                self.current_dataset.dqx_data = np.append( 
     855                    self.current_dataset.dqx_data, np.zeros([array_size])) 
     856            if not di_exists: 
     857                array_size = self.current_dataset.data.size - 1 
     858                self.current_dataset.err_data = np.append( 
     859                    self.current_dataset.err_data, np.zeros([array_size])) 
     860            if not mask_exists: 
     861                array_size = self.current_dataset.data.size - 1 
     862                self.current_dataset.mask = np.append( 
     863                    self.current_dataset.mask, 
     864                    np.ones([array_size] ,dtype=bool)) 
    767865 
    768866    ####### All methods below are for writing CanSAS XML files ####### 
    769  
    770867 
    771868    def write(self, filename, datainfo): 
    … …  
    792889        :param datainfo: Data1D object 
    793890        """ 
    794         if not issubclass(datainfo.__class__, Data1D): 
    795             raise RuntimeError, "The cansas writer expects a Data1D instance" 
     891        is_2d = False 
     892        if issubclass(datainfo.__class__, Data2D): 
     893            is_2d = True 
    796894 
    797895        # Get PIs and create root element 
    … …  
    813911        self._write_run_names(datainfo, entry_node) 
    814912        # Add Data info to SASEntry 
    815         self._write_data(datainfo, entry_node) 
     913        if is_2d: 
     914            self._write_data_2d(datainfo, entry_node) 
     915        else: 
     916            self._write_data(datainfo, entry_node) 
    816917        # Transmission Spectrum Info 
    817918        self._write_trans_spectrum(datainfo, entry_node) 
    … …  
    9071008    def _write_data(self, datainfo, entry_node): 
    9081009        """ 
    909         Writes the I and Q data to the XML file 
     1010        Writes 1D I and Q data to the XML file 
    9101011 
    9111012        :param datainfo: The Data1D object the information is coming from 
    … …  
    9351036                self.write_node(point, "dQl", datainfo.dxl[i], 
    9361037                                {'unit': datainfo.x_unit}) 
     1038 
     1039    def _write_data_2d(self, datainfo, entry_node): 
     1040        """ 
     1041        Writes 2D data to the XML file 
     1042 
     1043        :param datainfo: The Data2D object the information is coming from 
     1044        :param entry_node: lxml node ElementTree object to be appended to 
     1045        """ 
     1046        attr = {} 
     1047        if datainfo.data.shape: 
     1048            attr["x_bins"] = str(len(datainfo.x_bins)) 
     1049            attr["y_bins"] = str(len(datainfo.y_bins)) 
     1050        node = self.create_element("SASdata", attr) 
     1051        self.append(node, entry_node) 
     1052 
     1053        point = self.create_element("Idata") 
     1054        node.append(point) 
     1055        qx = ','.join([str(datainfo.qx_data[i]) for i in xrange(len(datainfo.qx_data))]) 
     1056        qy = ','.join([str(datainfo.qy_data[i]) for i in xrange(len(datainfo.qy_data))]) 
     1057        intensity = ','.join([str(datainfo.data[i]) for i in xrange(len(datainfo.data))]) 
     1058 
     1059        self.write_node(point, "Qx", qx, 
     1060                        {'unit': datainfo._xunit}) 
     1061        self.write_node(point, "Qy", qy, 
     1062                        {'unit': datainfo._yunit}) 
     1063        self.write_node(point, "I", intensity, 
     1064                        {'unit': datainfo._zunit}) 
     1065        if datainfo.err_data is not None: 
     1066            err = ','.join([str(datainfo.err_data[i]) for i in 
     1067                            xrange(len(datainfo.err_data))]) 
     1068            self.write_node(point, "Idev", err, 
     1069                            {'unit': datainfo._zunit}) 
     1070        if datainfo.dqy_data is not None: 
     1071            dqy = ','.join([str(datainfo.dqy_data[i]) for i in 
     1072                            xrange(len(datainfo.dqy_data))]) 
     1073            self.write_node(point, "Qydev", dqy, 
     1074                            {'unit': datainfo._yunit}) 
     1075        if datainfo.dqx_data is not None: 
     1076            dqx = ','.join([str(datainfo.dqx_data[i]) for i in 
     1077                            xrange(len(datainfo.dqx_data))]) 
     1078            self.write_node(point, "Qxdev", dqx, 
     1079                            {'unit': datainfo._xunit}) 
     1080        if datainfo.mask is not None: 
     1081            mask = ','.join( 
     1082                ["1" if datainfo.mask[i] else "0" 
     1083                 for i in xrange(len(datainfo.mask))]) 
     1084            self.write_node(point, "Mask", mask) 
    9371085 
    9381086    def _write_trans_spectrum(self, datainfo, entry_node): 

  • src/sas/sascalc/dataloader/readers/schema/cansas1d_invalid_v1_0.xsd

    r250fec92 raf08e55  
    2424 
    2525        <complexType name="IdataType"> 
     26                <xsd:choice> 
    2627                <sequence> 
    2728                        <element name="Q" minOccurs="1" maxOccurs="1"    type="tns:floatUnitType" /> 
    … …  
    4041                        <xsd:any minOccurs="0" maxOccurs="unbounded" processContents="lax" namespace="##other" /> 
    4142                </sequence> 
     43                <sequence> 
     44                        <element name="Qx" minOccurs="1" maxOccurs="1"    type="tns:floatUnitType" /> 
     45                        <element name="Qy" minOccurs="1" maxOccurs="1"    type="tns:floatUnitType" /> 
     46                        <element name="I" minOccurs="1" maxOccurs="1"    type="tns:floatUnitType" /> 
     47                        <element name="Idev" minOccurs="0" maxOccurs="1" type="tns:floatUnitType" default="0" /> 
     48                        <element name="Qydev" minOccurs="0" maxOccurs="1" type="tns:floatUnitType" default="0" /> 
     49                        <element name="Qxdev" minOccurs="0" maxOccurs="1" type="tns:floatUnitType" default="0" /> 
     50                        <element name="Mask" minOccurs="0" maxOccurs="1" type="string" default="0" /> 
     51                </sequence> 
     52                </xsd:choice> 
    4253        </complexType> 
    4354         
    … …  
    5162                <attribute name="name" type="string" use="optional" default="" /> 
    5263                <attribute name="timestamp" type="dateTime" use="optional" /> 
     64                <attribute name="x_bins" type="string" use="optional" /> 
     65                <attribute name="y_bins" type="string" use="optional" /> 
    5366        </complexType> 
    5467 

  • src/sas/sascalc/dataloader/readers/schema/cansas1d_invalid_v1_1.xsd

    r250fec92 raf08e55  
    2424 
    2525        <complexType name="IdataType"> 
     26                <xsd:choice> 
    2627                <sequence> 
    2728                        <element name="Q" minOccurs="1" maxOccurs="1"    type="tns:floatUnitType" /> 
    … …  
    4041                        <xsd:any minOccurs="0" maxOccurs="unbounded" processContents="lax" namespace="##other" /> 
    4142                </sequence> 
     43                <sequence> 
     44                        <element name="Qx" minOccurs="1" maxOccurs="1"    type="tns:floatUnitType" /> 
     45                        <element name="Qy" minOccurs="1" maxOccurs="1"    type="tns:floatUnitType" /> 
     46                        <element name="I" minOccurs="1" maxOccurs="1"    type="tns:floatUnitType" /> 
     47                        <element name="Idev" minOccurs="0" maxOccurs="1" type="tns:floatUnitType" default="0" /> 
     48                        <element name="Qydev" minOccurs="0" maxOccurs="1" type="tns:floatUnitType" default="0" /> 
     49                        <element name="Qxdev" minOccurs="0" maxOccurs="1" type="tns:floatUnitType" default="0" /> 
     50                        <element name="Mask" minOccurs="0" maxOccurs="1" type="string" default="0" /> 
     51                </sequence> 
     52                </xsd:choice> 
    4253        </complexType> 
    4354         
    … …  
    5162                <attribute name="name" type="string" use="optional" default="" /> 
    5263                <attribute name="timestamp" type="dateTime" use="optional" /> 
     64                <attribute name="x_bins" type="string" use="optional" /> 
     65                <attribute name="y_bins" type="string" use="optional" /> 
    5366        </complexType> 
    5467 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/plotting.py

    r6ffa0dd rca224b1  
    134134        """ 
    135135        for group_id in self.plot_panels.keys(): 
    136             panel = self.plot_panels[group_id] 
    137             panel.graph.reset() 
    138             self.hide_panel(group_id) 
     136            self.clear_panel_by_id(group_id) 
    139137        self.plot_panels = {} 
    140138 

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

    r505706a ra6fccd7  
    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

    r313c5c9 r0de74af  
    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/sascalc/file_converter/c_ext/bsl_loader.c

    rdc8a553 r2ab9c432  
    11#include <Python.h> 
     2//#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION 
    23#include <numpy/arrayobject.h> 
    34#include <stdio.h> 
    … …  
    2122static PyObject *CLoader_init(CLoader *self, PyObject *args, PyObject *kwds) { 
    2223    const char *filename; 
    23     const int n_frames; 
    24     const int n_pixels; 
    25     const int n_rasters; 
    26     const int swap_bytes; 
     24    int n_frames; 
     25    int n_pixels; 
     26    int n_rasters; 
     27    int swap_bytes; 
    2728 
    2829    if (self != NULL) { 

  • src/sas/sasgui/guiframe/customdir.py

    r212bfc2 r73cbeec  
    3434        if not os.path.isfile(config_file): 
    3535            shutil.copyfile(os.path.join(path, "custom_config.py"), config_file) 
     36 
     37        #Adding SAS_OPENCL if it doesn't exist in the config file 
     38        # - to support backcompability 
     39        if not "SAS_OPENCL" in open(config_file).read(): 
     40            open(config_file,"a+").write("SAS_OPENCL = \"None\"\n") 
    3641    except: 
    3742        # Check for data path next to exe/zip file. 

  • src/sas/sasgui/guiframe/gui_manager.py

    r505706a r73cbeec  
    152152SPLASH_SCREEN_HEIGHT = config.SPLASH_SCREEN_HEIGHT 
    153153SS_MAX_DISPLAY_TIME = config.SS_MAX_DISPLAY_TIME 
     154SAS_OPENCL = config.SAS_OPENCL 
    154155if not WELCOME_PANEL_ON: 
    155156    WELCOME_PANEL_SHOW = False 
    … …  
    176177    else: 
    177178        DEFAULT_OPEN_FOLDER = PATH_APP 
     179    SAS_OPENCL = custom_config.SAS_OPENCL 
    178180except: 
    179181    DATALOADER_SHOW = True 
    … …  
    190192    CLEANUP_PLOT = False 
    191193    DEFAULT_OPEN_FOLDER = PATH_APP 
    192  
     194    SAS_OPENCL = None 
    193195DEFAULT_STYLE = config.DEFAULT_STYLE 
    194196 
    … …  
    225227        CHILD_FRAME = wx.Frame 
    226228 
     229#Initiliaze enviromental variable with custom setting but only if variable not set 
     230if SAS_OPENCL and not "SAS_OPENCL" in os.environ: 
     231    os.environ["SAS_OPENCL"] = SAS_OPENCL 
    227232 
    228233class ViewerFrame(PARENT_FRAME): 
    … …  
    21042109        Quit the application 
    21052110        """ 
     2111        #IF SAS_OPENCL is set, settings are stored in the custom config file 
     2112        self._write_opencl_config_file() 
    21062113        logging.info(" --- SasView session was closed --- \n") 
    21072114        wx.Exit() 
    21082115        sys.exit() 
     2116 
     2117    def _write_opencl_config_file(self): 
     2118        """ 
     2119        Writes OpenCL settings to custom config file, so they can be remmbered 
     2120        from session to session 
     2121        """ 
     2122        if custom_config is not None: 
     2123            sas_opencl = os.environ.get("SAS_OPENCL",None) 
     2124            new_config_lines = [] 
     2125            config_file = open(custom_config.__file__) 
     2126            config_lines = config_file.readlines() 
     2127            for line in config_lines: 
     2128                if "SAS_OPENCL" in line: 
     2129                    if sas_opencl: 
     2130                        new_config_lines.append("SAS_OPENCL = \""+sas_opencl+"\"") 
     2131                    else: 
     2132                        new_config_lines.append("SAS_OPENCL = None") 
     2133                else: 
     2134                    new_config_lines.append(line) 
     2135            config_file.close() 
     2136 
     2137            #If custom_config is None, settings will not be remmbered 
     2138            new_config_file = open(custom_config.__file__,"w") 
     2139            new_config_file.writelines(new_config_lines) 
     2140            new_config_file.close() 
     2141        else: 
     2142            logging.info("Failed to save OPENCL settings in custom config file") 
     2143 
    21092144 
    21102145    def _check_update(self, event=None): 

  • src/sas/sasgui/guiframe/startup_configuration.py

    rd85c194 r73cbeec  
    3131                   'CLEANUP_PLOT':False, 
    3232                   'DEFAULT_PERSPECTIVE':'Fitting', 
    33                    'DEFAULT_OPEN_FOLDER': None} 
     33                   'DEFAULT_OPEN_FOLDER': None, 
     34                   'SAS_OPENCL': None} 
    3435try: 
    3536    CURRENT_STRINGS = {'GUIFRAME_WIDTH':CURRENT.GUIFRAME_WIDTH, 
    … …  
    4546                       'CLEANUP_PLOT':CURRENT.CLEANUP_PLOT, 
    4647                       'DEFAULT_PERSPECTIVE':CURRENT.DEFAULT_PERSPECTIVE, 
    47                        'DEFAULT_OPEN_FOLDER':CURRENT.DEFAULT_OPEN_FOLDER} 
     48                       'DEFAULT_OPEN_FOLDER':CURRENT.DEFAULT_OPEN_FOLDER, 
     49                       'SAS_OPENCL': None} 
    4850except: 
    4951    CURRENT_STRINGS = DEFAULT_STRINGS 

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

    r96d293da r1dc8ec9  
    3232        self._always_active = True 
    3333        self.state_reader = Reader(self.set_state) 
    34         self._extensions = '.cor' 
     34        self._extensions = '.crf' 
    3535 
    3636    def get_panels(self, parent): 
    … …  
    4848 
    4949        l = Loader() 
    50         l.associate_file_reader('.cor', self.state_reader) 
     50        l.associate_file_reader('.crf', self.state_reader) 
    5151 
    5252        return [self.corfunc_panel] 
    … …  
    6767            return [] 
    6868        data = plotpanel.plots[graph.selected_plottable] 
    69         if data.id == IQ_DATA_LABEL or data.id == IQ_EXTRAPOLATED_DATA_LABEL or data.id == TRANSFORM_LABEL: 
     69        if data.id == IQ_DATA_LABEL or data.id == IQ_EXTRAPOLATED_DATA_LABEL or data.id == TRANSFORM_LABEL1 or data.id == TRANSFORM_LABEL3: 
    7070            return [] 
    7171        item = plotpanel.plots[graph.selected_plottable] 
    … …  
    8181    def set_state(self, state=None, datainfo=None): 
    8282        """ 
    83         Callback for CorfuncState reader. Called when a .cor file is loaded 
     83        Callback for CorfuncState reader. Called when a .crf file is loaded 
    8484        """ 
    8585        if isinstance(datainfo, list): 
    … …  
    179179                # Show the extrapolation as a curve instead of points 
    180180                new_plot.symbol = GUIFRAME_ID.CURVE_SYMBOL_NUM 
    181         elif label == TRANSFORM_LABEL: 
     181        elif label == TRANSFORM_LABEL1 or label == TRANSFORM_LABEL3: 
    182182            new_plot.xaxis("{x}", 'A') 
    183183            new_plot.yaxis("{\\Gamma}", '') 

  • src/sas/sasgui/perspectives/corfunc/corfunc_panel.py

    rd45d590 r1dc8ec9  
    274274        plot_x = transform.x[np.where(transform.x <= 200)] 
    275275        plot_y = transform.y[np.where(transform.x <= 200)] 
    276         self._manager.show_data(Data1D(plot_x, plot_y), TRANSFORM_LABEL) 
     276        self._manager.show_data(Data1D(plot_x, plot_y), TRANSFORM_LABEL1) 
    277277        # Only enable extract params button if a fourier trans. has been done 
    278278        if self.transform_type == 'fourier': 
    … …  
    325325        dlg = wx.FileDialog(self, "Choose a file", 
    326326                            default_save_location, \ 
    327                             self.window_caption, "*.cor", wx.SAVE) 
     327                            self.window_caption, "*.crf", wx.SAVE) 
    328328        if dlg.ShowModal() == wx.ID_OK: 
    329329            path = dlg.GetPath() 
    … …  
    336336        dlg.Destroy() 
    337337        # MAC always needs the extension for saving 
    338         extens = ".cor" 
     338        extens = ".crf" 
    339339        # Make sure the ext included in the file name 
    340340        f_name = os.path.splitext(path)[0] + extens 

  • src/sas/sasgui/perspectives/corfunc/corfunc_state.py

    rd45d590 rae9b8bf  
    9696            self.background = value 
    9797 
    98     def toXML(self, filename='corfunc_state.cor', doc=None, entry_node=None): 
     98    def toXML(self, filename='corfunc_state.crf', doc=None, entry_node=None): 
    9999        """ 
    100100        Writes the state of the CorfuncPanel panel to file, as XML. 
    … …  
    257257    type_name = "Corfunc" 
    258258 
    259     type = ["Corfunc file (*.cor)|*.cor", 
     259    type = ["Corfunc file (*.crf)|*.crf", 
    260260            "SASView file (*.svs)|*.svs"] 
    261261 
    262     ext = ['.cor', '.COR', '.svs', '.SVS'] 
     262    ext = ['.crf', '.CRF', '.svs', '.SVS'] 
    263263 
    264264    def __init__(self, callback): 

  • src/sas/sasgui/perspectives/corfunc/plot_labels.py

    rff11b21 r1dc8ec9  
    44 
    55GROUP_ID_TRANSFORM = r"$\Gamma(x)$" 
    6 TRANSFORM_LABEL = r"$\Gamma(x)$" 
     6TRANSFORM_LABEL1 = r"$\Gamma1(x)$" 
     7TRANSFORM_LABEL3 = r"$\Gamma3(x)$" 

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

    r06a4306 r73cbeec  
    4545from sas.sasgui.guiframe.gui_manager import MDIFrame 
    4646from sas.sasgui.guiframe.documentation_window import DocumentationWindow 
     47from sas.sasgui.perspectives.fitting.gpu_options import GpuOptions 
    4748 
    4849from . import models 
    … …  
    192193        self.bumps_options_menu = self.menu1.FindItemById(self.id_bumps_options) 
    193194        self.bumps_options_menu.Enable(True) 
     195 
     196        self.id_gpu_options_panel = wx.NewId() 
     197        self.menu1.Append(self.id_gpu_options_panel, "OpenCL Options", "Choose OpenCL driver or turn it off") 
     198        wx.EVT_MENU(owner, self.id_gpu_options_panel, self.on_gpu_options) 
    194199 
    195200        self.id_result_panel = wx.NewId() 
    … …  
    801806        self.result_frame.Show() 
    802807        self.result_frame.Raise() 
     808 
     809    def on_gpu_options(self, event=None): 
     810        """ 
     811        Make the Fit Results panel visible. 
     812        """ 
     813        dialog = GpuOptions(None, wx.ID_ANY, "") 
     814        dialog.Show() 
    803815 
    804816    def stop_fit(self, uid): 

  • src/sas/sasgui/perspectives/fitting/media/plugin.rst

    rca1eaeb rca6cbc1c  
    568568    cube(x): 
    569569        $x^3$ 
    570     sinc(x): 
     570    sas_sinx_x(x): 
    571571        $\sin(x)/x$, with limit $\sin(0)/0 = 1$. 
    572572    powr(x, y): 
    … …  
    669669        (`link to Bessel function's code <https://github.com/SasView/sasmodels/tree/master/sasmodels/models/lib/sas_JN.c>`_) 
    670670 
    671     Si(x): 
     671    sas_Si(x): 
    672672        Sine integral $\text{Si}(x) = \int_0^x \tfrac{\sin t}{t}\,dt$. 
    673673 
    … …  
    693693        (`link to code <https://github.com/SasView/sasmodels/tree/master/sasmodels/models/lib/Si.c>`_) 
    694694 
    695     sph_j1c(x): 
     695    sas_3j1x_x(x): 
    696696        Spherical Bessel form 
    697697        $\text{sph_j1c}(x) = 3 j_1(x)/x = 3 (\sin(x) - x \cos(x))/x^3$, 
    … …  
    701701        This function uses a Taylor series for small $x$ for numerical accuracy. 
    702702 
    703         :code:`source = ["lib/sph_j1c.c", ...]` 
    704         (`link to code <https://github.com/SasView/sasmodels/tree/master/sasmodels/models/lib/sph_j1c.c>`_) 
    705  
    706  
    707     sas_J1c(x): 
     703        :code:`source = ["lib/sas_3j1x_x.c", ...]` 
     704        (`link to code <https://github.com/SasView/sasmodels/tree/master/sasmodels/models/lib/sas_3j1x_x.c>`_) 
     705 
     706 
     707    sas_2J1x_x(x): 
    708708        Bessel form $\text{sas_J1c}(x) = 2 J_1(x)/x$, with a limiting value 
    709709        of 1 at $x=0$, where $J_1(x)$ is the Bessel function of first kind 

  • src/sas/sasgui/perspectives/fitting/media/sm_help.rst

    r7805458 r27aabc1  
    2020================== 
    2121 
    22 Sometimes it will be necessary to correct reduced experimental data for the 
    23 physical effects of the instrumental geometry in use. This process is called 
    24 *desmearing*. However, calculated/simulated data - which by definition will be 
    25 perfect/exact - can be *smeared* to make it more representative of what might 
    26 actually be measured experimentally. 
    27  
    28 SasView provides the following three smearing algorithms: 
     22Sometimes the instrumental geometry used to acquire the experimental data has  
     23an impact on the clarity of features in the reduced scattering curve. For  
     24example, peaks or fringes might be slightly broadened. This is known as  
     25*Q resolution smearing*. To compensate for this effect one can either try and  
     26remove the resolution contribution - a process called *desmearing* - or add the  
     27resolution contribution into a model calculation/simulation (which by definition  
     28will be exact) to make it more representative of what has been measured  
     29experimentally - a process called *smearing*. SasView will do the latter. 
     30 
     31Both smearing and desmearing rely on functions to describe the resolution  
     32effect. SasView provides three smearing algorithms: 
    2933 
    3034*  *Slit Smearing* 
    3135*  *Pinhole Smearing* 
    3236*  *2D Smearing* 
     37 
     38SasView also has an option to use Q resolution data (estimated at the time of  
     39data reduction) supplied in a reduced data file: the *Use dQ data* radio button. 
     40 
     41.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 
     42 
     43dQ Smearing 
     44----------- 
     45  
     46If this option is checked, SasView will assume that the supplied dQ values  
     47represent the standard deviations of Gaussian functions. 
    3348 
    3449.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 

  • src/sas/sasgui/perspectives/pr/media/pr_help.rst

    r0391dae r1221196  
    1010----------- 
    1111 
    12 This tool calculates a real-space distance distribution function, *P(r)*, using  
    13 the inversion approach (Moore, 1908). 
     12This tool calculates a real-space distance distribution function, *P(r)*, using 
     13the inversion approach (Moore, 1980). 
    1414 
    1515*P(r)* is set to be equal to an expansion of base functions of the type 
    … …  
    2424 
    2525  \chi^2=\frac{\sum_i (I_{meas}(Q_i)-I_{th}(Q_i))^2}{error^2}+Reg\_term 
    26    
     26 
    2727 
    2828where $I_{meas}(Q_i)$ is the measured scattering intensity and $I_{th}(Q_i)$ is 
    29 the prediction from the Fourier transform of the *P(r)* expansion.  
     29the prediction from the Fourier transform of the *P(r)* expansion. 
    3030 
    31 The $Reg\_term$ term is a regularization term set to the second derivative  
     31The $Reg\_term$ term is a regularization term set to the second derivative 
    3232$d^2P(r)/d^2r$ integrated over $r$. It is used to produce a smooth *P(r)* output. 
    3333 
    … …  
    4040 
    4141*  *Number of terms*: the number of base functions in the P(r) expansion. 
    42     
     42 
    4343*  *Regularization constant*: a multiplicative constant to set the size of 
    4444   the regularization term. 
Note: See TracChangeset for help on using the changeset viewer.