Changes in / [12361fd:18b7ca96] in sasview


Ignore:
Location:
src/sas
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r654e8e0 r1905128  
    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 = 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        err = ','.join([str(datainfo.err_data[i]) for i in xrange(len(datainfo.err_data))]) 
     1059        dqy = ','.join([str(datainfo.dqy_data[i]) for i in xrange(len(datainfo.dqy_data))]) 
     1060        dqx = ','.join([str(datainfo.dqx_data[i]) for i in xrange(len(datainfo.dqx_data))]) 
     1061        mask = ','.join([str(datainfo.mask[i]) for i in xrange(len(datainfo.mask))]) 
     1062 
     1063        self.write_node(point, "Qx", qx, 
     1064                        {'unit': datainfo._xunit}) 
     1065        self.write_node(point, "Qy", qy, 
     1066                        {'unit': datainfo._yunit}) 
     1067        self.write_node(point, "I", intensity, 
     1068                        {'unit': datainfo._zunit}) 
     1069        if datainfo.err_data is not None: 
     1070            self.write_node(point, "Idev", err, 
     1071                            {'unit': datainfo._zunit}) 
     1072        if datainfo.dqy_data is not None: 
     1073            self.write_node(point, "Qydev", dqy, 
     1074                            {'unit': datainfo._yunit}) 
     1075        if datainfo.dqx_data is not None: 
     1076            self.write_node(point, "Qxdev", dqx, 
     1077                            {'unit': datainfo._xunit}) 
     1078        if datainfo.mask is not None: 
     1079            self.write_node(point, "Mask", mask) 
    9371080 
    9381081    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/perspectives/fitting/model_thread.py

    rd3911e3 rc1681ea  
    197197            output[index] = self.model.evalDistribution(self.data.x[index]) 
    198198 
    199         sq_model = None 
    200         pq_model = None 
     199        sq_values = None 
     200        pq_values = None 
     201        s_model = None 
     202        p_model = None 
    201203        if isinstance(self.model, MultiplicationModel): 
    202             sq_model = numpy.zeros((len(self.data.x))) 
    203             pq_model = numpy.zeros((len(self.data.x))) 
    204             sq_model[index] = self.model.s_model.evalDistribution(self.data.x[index]) 
    205             pq_model[index] = self.model.p_model.evalDistribution(self.data.x[index]) 
     204            s_model = self.model.s_model 
     205            p_model = self.model.p_model 
     206        elif hasattr(self.model, "get_composition_models"): 
     207            p_model, s_model = self.model.get_composition_models() 
     208 
     209        if p_model is not None and s_model is not None: 
     210            sq_values = numpy.zeros((len(self.data.x))) 
     211            pq_values = numpy.zeros((len(self.data.x))) 
     212            sq_values[index] = s_model.evalDistribution(self.data.x[index]) 
     213            pq_values[index] = p_model.evalDistribution(self.data.x[index]) 
    206214 
    207215        elapsed = time.time() - self.starttime 
    … …  
    220228                      unsmeared_data=unsmeared_data, 
    221229                      unsmeared_error=unsmeared_error, 
    222                       pq_model=pq_model, 
    223                       sq_model=sq_model) 
     230                      pq_model=pq_values, 
     231                      sq_model=sq_values) 
    224232 
    225233    def results(self): 

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

    r12361fd raf08e55  
    11791179            return self._read_cansas(path) 
    11801180 
    1181     def _data2d_to_xml_doc(self, datainfo): 
    1182         """ 
    1183         Create an XML document to contain the content of a Data2D 
    1184  
    1185         :param datainfo: Data2D object 
    1186  
    1187         """ 
    1188         if not issubclass(datainfo.__class__, Data2D): 
    1189             raise RuntimeError, "The cansas writer expects a Data2D instance" 
    1190  
    1191         title = "cansas1d/%s" % self.version 
    1192         title += "http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" 
    1193         doc = xml.dom.minidom.Document() 
    1194         main_node = doc.createElement("SASroot") 
    1195         main_node.setAttribute("version", self.version) 
    1196         main_node.setAttribute("xmlns", "cansas1d/%s" % self.version) 
    1197         main_node.setAttribute("xmlns:xsi", 
    1198                                "http://www.w3.org/2001/XMLSchema-instance") 
    1199         main_node.setAttribute("xsi:schemaLocation", title) 
    1200  
    1201         doc.appendChild(main_node) 
    1202  
    1203         entry_node = doc.createElement("SASentry") 
    1204         main_node.appendChild(entry_node) 
    1205  
    1206         write_node(doc, entry_node, "Title", datainfo.title) 
    1207         if datainfo is not None: 
    1208             write_node(doc, entry_node, "data_class", 
    1209                        datainfo.__class__.__name__) 
    1210         for item in datainfo.run: 
    1211             runname = {} 
    1212             if item in datainfo.run_name and \ 
    1213                             len(str(datainfo.run_name[item])) > 1: 
    1214                 runname = {'name': datainfo.run_name[item]} 
    1215             write_node(doc, entry_node, "Run", item, runname) 
    1216         # Data info 
    1217         new_node = doc.createElement("SASdata") 
    1218         entry_node.appendChild(new_node) 
    1219         for item in LIST_OF_DATA_2D_ATTR: 
    1220             element = doc.createElement(item[0]) 
    1221             element.setAttribute(item[0], str(getattr(datainfo, item[1]))) 
    1222             new_node.appendChild(element) 
    1223  
    1224         for item in LIST_OF_DATA_2D_VALUES: 
    1225             root_node = doc.createElement(item[0]) 
    1226             new_node.appendChild(root_node) 
    1227             temp_list = getattr(datainfo, item[1]) 
    1228  
    1229             if temp_list is None or len(temp_list) == 0: 
    1230                 element = doc.createElement(item[0]) 
    1231                 element.appendChild(doc.createTextNode(str(temp_list))) 
    1232                 root_node.appendChild(element) 
    1233             else: 
    1234                 for value in temp_list: 
    1235                     element = doc.createElement(item[0]) 
    1236                     element.setAttribute(item[0], str(value)) 
    1237                     root_node.appendChild(element) 
    1238  
    1239         # Sample info 
    1240         sample = doc.createElement("SASsample") 
    1241         if datainfo.sample.name is not None: 
    1242             sample.setAttribute("name", str(datainfo.sample.name)) 
    1243         entry_node.appendChild(sample) 
    1244         write_node(doc, sample, "ID", str(datainfo.sample.ID)) 
    1245         write_node(doc, sample, "thickness", datainfo.sample.thickness, 
    1246                    {"unit": datainfo.sample.thickness_unit}) 
    1247         write_node(doc, sample, "transmission", datainfo.sample.transmission) 
    1248         write_node(doc, sample, "temperature", datainfo.sample.temperature, 
    1249                    {"unit": datainfo.sample.temperature_unit}) 
    1250  
    1251         for item in datainfo.sample.details: 
    1252             write_node(doc, sample, "details", item) 
    1253  
    1254         pos = doc.createElement("position") 
    1255         written = write_node(doc, pos, "x", datainfo.sample.position.x, 
    1256                              {"unit": datainfo.sample.position_unit}) 
    1257         written = written | write_node(doc, pos, "y", 
    1258                                        datainfo.sample.position.y, 
    1259                                        {"unit": datainfo.sample.position_unit}) 
    1260         written = written | write_node(doc, pos, "z", 
    1261                                        datainfo.sample.position.z, 
    1262                                        {"unit": datainfo.sample.position_unit}) 
    1263         if written: 
    1264             sample.appendChild(pos) 
    1265  
    1266         ori = doc.createElement("orientation") 
    1267         written = write_node(doc, ori, "roll", datainfo.sample.orientation.x, 
    1268                              {"unit": datainfo.sample.orientation_unit}) 
    1269         written = written | write_node(doc, ori, "pitch", 
    1270                                        datainfo.sample.orientation.y, 
    1271                                        {"unit": 
    1272                                             datainfo.sample.orientation_unit}) 
    1273         written = written | write_node(doc, ori, "yaw", 
    1274                                        datainfo.sample.orientation.z, 
    1275                                        {"unit": 
    1276                                             datainfo.sample.orientation_unit}) 
    1277         if written: 
    1278             sample.appendChild(ori) 
    1279  
    1280         # Instrument info 
    1281         instr = doc.createElement("SASinstrument") 
    1282         entry_node.appendChild(instr) 
    1283  
    1284         write_node(doc, instr, "name", datainfo.instrument) 
    1285  
    1286         #   Source 
    1287         source = doc.createElement("SASsource") 
    1288         if datainfo.source.name is not None: 
    1289             source.setAttribute("name", str(datainfo.source.name)) 
    1290         instr.appendChild(source) 
    1291  
    1292         write_node(doc, source, "radiation", datainfo.source.radiation) 
    1293         write_node(doc, source, "beam_shape", datainfo.source.beam_shape) 
    1294         size = doc.createElement("beam_size") 
    1295         if datainfo.source.beam_size_name is not None: 
    1296             size.setAttribute("name", str(datainfo.source.beam_size_name)) 
    1297         written = write_node(doc, size, "x", datainfo.source.beam_size.x, 
    1298                              {"unit": datainfo.source.beam_size_unit}) 
    1299         written = written | write_node(doc, size, "y", 
    1300                                        datainfo.source.beam_size.y, 
    1301                                        {"unit": datainfo.source.beam_size_unit}) 
    1302         written = written | write_node(doc, size, "z", 
    1303                                        datainfo.source.beam_size.z, 
    1304                                        {"unit": datainfo.source.beam_size_unit}) 
    1305         if written: 
    1306             source.appendChild(size) 
    1307  
    1308         write_node(doc, source, "wavelength", datainfo.source.wavelength, 
    1309                    {"unit": datainfo.source.wavelength_unit}) 
    1310         write_node(doc, source, "wavelength_min", 
    1311                    datainfo.source.wavelength_min, 
    1312                    {"unit": datainfo.source.wavelength_min_unit}) 
    1313         write_node(doc, source, "wavelength_max", 
    1314                    datainfo.source.wavelength_max, 
    1315                    {"unit": datainfo.source.wavelength_max_unit}) 
    1316         write_node(doc, source, "wavelength_spread", 
    1317                    datainfo.source.wavelength_spread, 
    1318                    {"unit": datainfo.source.wavelength_spread_unit}) 
    1319  
    1320         #   Collimation 
    1321         for item in datainfo.collimation: 
    1322             coll = doc.createElement("SAScollimation") 
    1323             if item.name is not None: 
    1324                 coll.setAttribute("name", str(item.name)) 
    1325             instr.appendChild(coll) 
    1326  
    1327             write_node(doc, coll, "length", item.length, 
    1328                        {"unit": item.length_unit}) 
    1329  
    1330             for apert in item.aperture: 
    1331                 ap = doc.createElement("aperture") 
    1332                 if apert.name is not None: 
    1333                     ap.setAttribute("name", str(apert.name)) 
    1334                 if apert.type is not None: 
    1335                     ap.setAttribute("type", str(apert.type)) 
    1336                 coll.appendChild(ap) 
    1337  
    1338                 write_node(doc, ap, "distance", apert.distance, 
    1339                            {"unit": apert.distance_unit}) 
    1340  
    1341                 size = doc.createElement("size") 
    1342                 if apert.size_name is not None: 
    1343                     size.setAttribute("name", str(apert.size_name)) 
    1344                 written = write_node(doc, size, "x", apert.size.x, 
    1345                                      {"unit": apert.size_unit}) 
    1346                 written = written | write_node(doc, size, "y", apert.size.y, 
    1347                                                {"unit": apert.size_unit}) 
    1348                 written = written | write_node(doc, size, "z", apert.size.z, 
    1349                                                {"unit": apert.size_unit}) 
    1350                 if written: 
    1351                     ap.appendChild(size) 
    1352  
    1353         #   Detectors 
    1354         for item in datainfo.detector: 
    1355             det = doc.createElement("SASdetector") 
    1356             written = write_node(doc, det, "name", item.name) 
    1357             written = written | write_node(doc, det, "SDD", item.distance, 
    1358                                            {"unit": item.distance_unit}) 
    1359             written = written | write_node(doc, det, "slit_length", 
    1360                                            item.slit_length, 
    1361                                            {"unit": item.slit_length_unit}) 
    1362             if written: 
    1363                 instr.appendChild(det) 
    1364  
    1365             off = doc.createElement("offset") 
    1366             written = write_node(doc, off, "x", item.offset.x, 
    1367                                  {"unit": item.offset_unit}) 
    1368             written = written | write_node(doc, off, "y", item.offset.y, 
    1369                                            {"unit": item.offset_unit}) 
    1370             written = written | write_node(doc, off, "z", item.offset.z, 
    1371                                            {"unit": item.offset_unit}) 
    1372             if written: 
    1373                 det.appendChild(off) 
    1374  
    1375             center = doc.createElement("beam_center") 
    1376             written = write_node(doc, center, "x", item.beam_center.x, 
    1377                                  {"unit": item.beam_center_unit}) 
    1378             written = written | write_node(doc, center, "y", 
    1379                                            item.beam_center.y, 
    1380                                            {"unit": item.beam_center_unit}) 
    1381             written = written | write_node(doc, center, "z", 
    1382                                            item.beam_center.z, 
    1383                                            {"unit": item.beam_center_unit}) 
    1384             if written: 
    1385                 det.appendChild(center) 
    1386  
    1387             pix = doc.createElement("pixel_size") 
    1388             written = write_node(doc, pix, "x", item.pixel_size.x, 
    1389                                  {"unit": item.pixel_size_unit}) 
    1390             written = written | write_node(doc, pix, "y", item.pixel_size.y, 
    1391                                            {"unit": item.pixel_size_unit}) 
    1392             written = written | write_node(doc, pix, "z", item.pixel_size.z, 
    1393                                            {"unit": item.pixel_size_unit}) 
    1394             if written: 
    1395                 det.appendChild(pix) 
    1396  
    1397             ori = doc.createElement("orientation") 
    1398             written = write_node(doc, ori, "roll", item.orientation.x, 
    1399                                  {"unit": item.orientation_unit}) 
    1400             written = written | write_node(doc, ori, "pitch", 
    1401                                            item.orientation.y, 
    1402                                            {"unit": item.orientation_unit}) 
    1403             written = written | write_node(doc, ori, "yaw", item.orientation.z, 
    1404                                            {"unit": item.orientation_unit}) 
    1405             if written: 
    1406                 det.appendChild(ori) 
    1407  
    1408         # Processes info 
    1409         for item in datainfo.process: 
    1410             node = doc.createElement("SASprocess") 
    1411             entry_node.appendChild(node) 
    1412  
    1413             write_node(doc, node, "name", item.name) 
    1414             write_node(doc, node, "date", item.date) 
    1415             write_node(doc, node, "description", item.description) 
    1416             for term in item.term: 
    1417                 value = term['value'] 
    1418                 del term['value'] 
    1419                 write_node(doc, node, "term", value, term) 
    1420             for note in item.notes: 
    1421                 write_node(doc, node, "SASprocessnote", note) 
    1422         # Return the document, and the SASentry node associated with 
    1423         # the data we just wrote 
    1424         return doc, entry_node 
    1425  
    14261181    def _parse_state(self, entry): 
    14271182        """ 
    … …  
    14991254        """ 
    15001255        node = dom.xpath('ns:data_class', namespaces={'ns': CANSAS_NS}) 
    1501         if not node or node[0].text.lstrip().rstrip() != "Data2D": 
    1502             return_value, _ = self._parse_entry(dom) 
    1503             numpy.trim_zeros(return_value.x) 
    1504             numpy.trim_zeros(return_value.y) 
    1505             numpy.trim_zeros(return_value.dy) 
    1506             size_dx = return_value.dx.size 
    1507             size_dxl = return_value.dxl.size 
    1508             size_dxw = return_value.dxw.size 
    1509             if size_dxl == 0 and size_dxw == 0: 
    1510                 return_value.dxl = None 
    1511                 return_value.dxw = None 
    1512                 numpy.trim_zeros(return_value.dx) 
    1513             elif size_dx == 0: 
    1514                 return_value.dx = None 
    1515                 size_dx = size_dxl 
    1516                 numpy.trim_zeros(return_value.dxl) 
    1517                 numpy.trim_zeros(return_value.dxw) 
    1518  
    1519             return return_value, _ 
    1520  
    1521         # Parse 2D 
    1522         data_info = Data2D() 
    1523  
    1524         # Look up title 
    1525         self._store_content('ns:Title', dom, 'title', data_info) 
    1526  
    1527         # Look up run number 
    1528         nodes = dom.xpath('ns:Run', namespaces={'ns': CANSAS_NS}) 
    1529         for item in nodes: 
    1530             if item.text is not None: 
    1531                 value = item.text.strip() 
    1532                 if len(value) > 0: 
    1533                     data_info.run.append(value) 
    1534                     if item.get('name') is not None: 
    1535                         data_info.run_name[value] = item.get('name') 
    1536  
    1537         # Look up instrument name 
    1538         self._store_content('ns:SASinstrument/ns:name', dom, 
    1539                             'instrument', data_info) 
    1540  
    1541         # Notes 
    1542         note_list = dom.xpath('ns:SASnote', namespaces={'ns': CANSAS_NS}) 
    1543         for note in note_list: 
    1544             try: 
    1545                 if note.text is not None: 
    1546                     note_value = note.text.strip() 
    1547                     if len(note_value) > 0: 
    1548                         data_info.notes.append(note_value) 
    1549             except Exception: 
    1550                 err_mess = "cansas_reader.read: error processing entry notes\n" 
    1551                 err_mess += "  %s" % sys.exc_value 
    1552                 self.errors.append(err_mess) 
    1553                 logging.error(err_mess) 
    1554  
    1555         # Sample info ################### 
    1556         entry = get_content('ns:SASsample', dom) 
    1557         if entry is not None: 
    1558             data_info.sample.name = entry.get('name') 
    1559  
    1560         self._store_content('ns:SASsample/ns:ID', dom, 'ID', data_info.sample) 
    1561         self._store_float('ns:SASsample/ns:thickness', dom, 'thickness', 
    1562                           data_info.sample) 
    1563         self._store_float('ns:SASsample/ns:transmission', dom, 'transmission', 
    1564                           data_info.sample) 
    1565         self._store_float('ns:SASsample/ns:temperature', dom, 'temperature', 
    1566                           data_info.sample) 
    1567  
    1568         nodes = dom.xpath('ns:SASsample/ns:details', 
    1569                           namespaces={'ns': CANSAS_NS}) 
    1570         for item in nodes: 
    1571             try: 
    1572                 if item.text is not None: 
    1573                     detail_value = item.text.strip() 
    1574                     if len(detail_value) > 0: 
    1575                         data_info.sample.details.append(detail_value) 
    1576             except Exception: 
    1577                 err_mess = "cansas_reader.read: error processing entry notes\n" 
    1578                 err_mess += "  %s" % sys.exc_value 
    1579                 self.errors.append(err_mess) 
    1580                 logging.error(err_mess) 
    1581  
    1582         # Position (as a vector) 
    1583         self._store_float('ns:SASsample/ns:position/ns:x', dom, 'position.x', 
    1584                           data_info.sample) 
    1585         self._store_float('ns:SASsample/ns:position/ns:y', dom, 'position.y', 
    1586                           data_info.sample) 
    1587         self._store_float('ns:SASsample/ns:position/ns:z', dom, 'position.z', 
    1588                           data_info.sample) 
    1589  
    1590         # Orientation (as a vector) 
    1591         self._store_float('ns:SASsample/ns:orientation/ns:roll', 
    1592                           dom, 'orientation.x', data_info.sample) 
    1593         self._store_float('ns:SASsample/ns:orientation/ns:pitch', 
    1594                           dom, 'orientation.y', data_info.sample) 
    1595         self._store_float('ns:SASsample/ns:orientation/ns:yaw', 
    1596                           dom, 'orientation.z', data_info.sample) 
    1597  
    1598         # Source info ################### 
    1599         entry = get_content('ns:SASinstrument/ns:SASsource', dom) 
    1600         if entry is not None: 
    1601             data_info.source.name = entry.get('name') 
    1602  
    1603         self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation', 
    1604                             dom, 'radiation', data_info.source) 
    1605         self._store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape', 
    1606                             dom, 'beam_shape', data_info.source) 
    1607         self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength', 
    1608                           dom, 'wavelength', data_info.source) 
    1609         self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min', 
    1610                           dom, 'wavelength_min', data_info.source) 
    1611         self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max', 
    1612                           dom, 'wavelength_max', data_info.source) 
    1613         self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread', 
    1614                           dom, 'wavelength_spread', data_info.source) 
    1615  
    1616         # Beam size (as a vector) 
    1617         entry = get_content('ns:SASinstrument/ns:SASsource/ns:beam_size', dom) 
    1618         if entry is not None: 
    1619             data_info.source.beam_size_name = entry.get('name') 
    1620  
    1621         self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x', 
    1622                           dom, 'beam_size.x', data_info.source) 
    1623         self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y', 
    1624                           dom, 'beam_size.y', data_info.source) 
    1625         self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z', 
    1626                           dom, 'beam_size.z', data_info.source) 
    1627  
    1628         # Collimation info ################### 
    1629         nodes = dom.xpath('ns:SASinstrument/ns:SAScollimation', 
    1630                           namespaces={'ns': CANSAS_NS}) 
    1631         for item in nodes: 
    1632             collim = Collimation() 
    1633             if item.get('name') is not None: 
    1634                 collim.name = item.get('name') 
    1635             self._store_float('ns:length', item, 'length', collim) 
    1636  
    1637             # Look for apertures 
    1638             apert_list = item.xpath('ns:aperture', 
    1639                                     namespaces={'ns': CANSAS_NS}) 
    1640             for apert in apert_list: 
    1641                 aperture = Aperture() 
    1642  
    1643                 # Get the name and type of the aperture 
    1644                 aperture.name = apert.get('name') 
    1645                 aperture.type = apert.get('type') 
    1646  
    1647                 self._store_float('ns:distance', apert, 'distance', aperture) 
    1648  
    1649                 entry = get_content('ns:size', apert) 
    1650                 if entry is not None: 
    1651                     aperture.size_name = entry.get('name') 
    1652  
    1653                 self._store_float('ns:size/ns:x', apert, 'size.x', aperture) 
    1654                 self._store_float('ns:size/ns:y', apert, 'size.y', aperture) 
    1655                 self._store_float('ns:size/ns:z', apert, 'size.z', aperture) 
    1656  
    1657                 collim.aperture.append(aperture) 
    1658  
    1659             data_info.collimation.append(collim) 
    1660  
    1661         # Detector info ###################### 
    1662         nodes = dom.xpath('ns:SASinstrument/ns:SASdetector', 
    1663                           namespaces={'ns': CANSAS_NS}) 
    1664         for item in nodes: 
    1665  
    1666             detector = Detector() 
    1667  
    1668             self._store_content('ns:name', item, 'name', detector) 
    1669             self._store_float('ns:SDD', item, 'distance', detector) 
    1670  
    1671             # Detector offset (as a vector) 
    1672             self._store_float('ns:offset/ns:x', item, 'offset.x', detector) 
    1673             self._store_float('ns:offset/ns:y', item, 'offset.y', detector) 
    1674             self._store_float('ns:offset/ns:z', item, 'offset.z', detector) 
    1675  
    1676             # Detector orientation (as a vector) 
    1677             self._store_float('ns:orientation/ns:roll', item, 
    1678                               'orientation.x', detector) 
    1679             self._store_float('ns:orientation/ns:pitch', item, 
    1680                               'orientation.y', detector) 
    1681             self._store_float('ns:orientation/ns:yaw', item, 
    1682                               'orientation.z', detector) 
    1683  
    1684             # Beam center (as a vector) 
    1685             self._store_float('ns:beam_center/ns:x', item, 
    1686                               'beam_center.x', detector) 
    1687             self._store_float('ns:beam_center/ns:y', item, 
    1688                               'beam_center.y', detector) 
    1689             self._store_float('ns:beam_center/ns:z', item, 
    1690                               'beam_center.z', detector) 
    1691  
    1692             # Pixel size (as a vector) 
    1693             self._store_float('ns:pixel_size/ns:x', item, 
    1694                               'pixel_size.x', detector) 
    1695             self._store_float('ns:pixel_size/ns:y', item, 
    1696                               'pixel_size.y', detector) 
    1697             self._store_float('ns:pixel_size/ns:z', item, 
    1698                               'pixel_size.z', detector) 
    1699  
    1700             self._store_float('ns:slit_length', item, 'slit_length', detector) 
    1701  
    1702             data_info.detector.append(detector) 
    1703  
    1704         # Processes info ###################### 
    1705         nodes = dom.xpath('ns:SASprocess', namespaces={'ns': CANSAS_NS}) 
    1706         for item in nodes: 
    1707             process = Process() 
    1708             self._store_content('ns:name', item, 'name', process) 
    1709             self._store_content('ns:date', item, 'date', process) 
    1710             self._store_content('ns:description', item, 'description', process) 
    1711  
    1712             term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS}) 
    1713             for term in term_list: 
    1714                 try: 
    1715                     term_attr = {} 
    1716                     for attr in term.keys(): 
    1717                         term_attr[attr] = term.get(attr).strip() 
    1718                     if term.text is not None: 
    1719                         term_attr['value'] = term.text.strip() 
    1720                         process.term.append(term_attr) 
    1721                 except: 
    1722                     err_mess = "cansas_reader.read: error processing " 
    1723                     err_mess += "entry notes\n  %s" % sys.exc_value 
    1724                     self.errors.append(err_mess) 
    1725                     logging.error(err_mess) 
    1726  
    1727             note_list = item.xpath('ns:SASprocessnote', 
    1728                                    namespaces={'ns': CANSAS_NS}) 
    1729             for note in note_list: 
    1730                 if note.text is not None: 
    1731                     process.notes.append(note.text.strip()) 
    1732  
    1733             data_info.process.append(process) 
    1734  
    1735         # Data info ###################### 
    1736         nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS}) 
    1737         if len(nodes) > 1: 
    1738             raise RuntimeError, "CanSAS reader is not compatible with" + \ 
    1739                                 " multiple SASdata entries" 
    1740  
    1741         for entry in nodes: 
    1742             for item in LIST_OF_DATA_2D_ATTR: 
    1743                 # get node 
    1744                 node = get_content('ns:%s' % item[0], entry) 
    1745                 setattr(data_info, item[1], parse_entry_helper(node, item)) 
    1746  
    1747             for item in LIST_OF_DATA_2D_VALUES: 
    1748                 field = get_content('ns:%s' % item[0], entry) 
    1749                 value_list = [] 
    1750                 if field is not None: 
    1751                     value_list = \ 
    1752                         [parse_entry_helper(node, item) for node in field] 
    1753                 if len(value_list) < 2: 
    1754                     setattr(data_info, item[0], None) 
    1755                 else: 
    1756                     setattr(data_info, item[0], numpy.array(value_list)) 
    1757  
    1758         return data_info 
     1256        return_value, _ = self._parse_entry(dom) 
     1257        return return_value, _ 
    17591258 
    17601259    def _read_cansas(self, path): 
    … …  
    18911390            state.data.run_name[0] = state.data.name 
    18921391 
    1893         if issubclass(state.data.__class__, 
    1894                       sas.sascalc.dataloader.data_info.Data1D): 
    1895             data = state.data 
    1896             doc, sasentry = self._to_xml_doc(data) 
    1897         else: 
    1898             data = state.data 
    1899             doc, sasentry = self._data2d_to_xml_doc(data) 
     1392        data = state.data 
     1393        doc, sasentry = self._to_xml_doc(data) 
    19001394 
    19011395        if state is not None: 
Note: See TracChangeset for help on using the changeset viewer.