Changeset 4abcc93a in sasview


Ignore:
Timestamp:
Aug 19, 2016 9:03:25 AM (3 years ago)
Author:
krzywon
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
b61bd57, b61796f
Parents:
5f26aa4 (diff), a4deca6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of https://github.com/SasView/sasview

Files:
5 edited

Legend:

Unmodified
Added
Removed
  • sasview/sasview.py

    re68c9bf rcde6e52  
    100100 
    101101from matplotlib import backend_bases 
    102 backend_bases._default_filetypes.pop('pgf', None) 
     102backend_bases.FigureCanvasBase.filetypes.pop('pgf', None) 
    103103 
    104104class SasView(): 
  • src/sas/sascalc/dataloader/data_info.py

    rd72567e ra4deca6  
    445445        return len(self.name) == 0 and len(self.date) == 0 and len(self.description) == 0 \ 
    446446            and len(self.term) == 0 and len(self.notes) == 0 
    447              
     447 
    448448    def single_line_desc(self): 
    449449        """ 
     
    451451        """ 
    452452        return "%s %s %s" % (self.name, self.date, self.description) 
    453       
     453 
    454454    def __str__(self): 
    455455        _str = "Process:\n" 
     
    12201220        result.mask = numpy.append(self.mask, other.mask) 
    12211221        if result.err_data is not None: 
    1222             result.err_data = numpy.append(self.err_data, other.err_data)  
     1222            result.err_data = numpy.append(self.err_data, other.err_data) 
    12231223        if self.dqx_data is not None: 
    12241224            result.dqx_data = numpy.append(self.dqx_data, other.dqx_data) 
     
    12521252        final_dataset.yaxis(data._yaxis, data._yunit) 
    12531253        final_dataset.zaxis(data._zaxis, data._zunit) 
     1254        final_dataset.x_bins = data.x_bins 
     1255        final_dataset.y_bins = data.y_bins 
    12541256    else: 
    12551257        return_string = "Should Never Happen: _combine_data_info_with_plottable input is not a plottable1d or " + \ 
  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    rd72567e ra4deca6  
    6262        :return: List of Data1D/2D objects and/or a list of errors. 
    6363        """ 
    64  
    6564        ## Reinitialize the class when loading a new data file to reset all class variables 
    6665        self.reset_class_variables() 
     
    136135                ## If this is a dataset, store the data appropriately 
    137136                data_set = data[key][:] 
     137                unit = self._get_unit(value) 
     138 
     139                ## I and Q Data 
     140                if key == u'I': 
     141                    if type(self.current_dataset) is plottable_2D: 
     142                        self.current_dataset.data = data_set 
     143                        self.current_dataset.zaxis("Intensity", unit) 
     144                    else: 
     145                        self.current_dataset.y = data_set.flatten() 
     146                        self.current_dataset.yaxis("Intensity", unit) 
     147                    continue 
     148                elif key == u'Idev': 
     149                    if type(self.current_dataset) is plottable_2D: 
     150                        self.current_dataset.err_data = data_set.flatten() 
     151                    else: 
     152                        self.current_dataset.dy = data_set.flatten() 
     153                    continue 
     154                elif key == u'Q': 
     155                    self.current_dataset.xaxis("Q", unit) 
     156                    if type(self.current_dataset) is plottable_2D: 
     157                        self.current_dataset.q = data_set.flatten() 
     158                    else: 
     159                        self.current_dataset.x = data_set.flatten() 
     160                    continue 
     161                elif key == u'Qy': 
     162                    self.current_dataset.yaxis("Q_y", unit) 
     163                    self.current_dataset.qy_data = data_set.flatten() 
     164                    continue 
     165                elif key == u'Qydev': 
     166                    self.current_dataset.dqy_data = data_set.flatten() 
     167                    continue 
     168                elif key == u'Qx': 
     169                    self.current_dataset.xaxis("Q_x", unit) 
     170                    self.current_dataset.qx_data = data_set.flatten() 
     171                    continue 
     172                elif key == u'Qxdev': 
     173                    self.current_dataset.dqx_data = data_set.flatten() 
     174                    continue 
     175                elif key == u'Mask': 
     176                    self.current_dataset.mask = data_set.flatten() 
     177                    continue 
    138178 
    139179                for data_point in data_set: 
    140180                    ## Top Level Meta Data 
    141                     unit = self._get_unit(value) 
    142181                    if key == u'definition': 
    143182                        self.current_datainfo.meta_data['reader'] = data_point 
     
    148187                    elif key == u'SASnote': 
    149188                        self.current_datainfo.notes.append(data_point) 
    150  
    151                     ## I and Q Data 
    152                     elif key == u'I': 
    153                         if type(self.current_dataset) is plottable_2D: 
    154                             self.current_dataset.data = np.append(self.current_dataset.data, data_point) 
    155                             self.current_dataset.zaxis("Intensity", unit) 
    156                         else: 
    157                             self.current_dataset.y = np.append(self.current_dataset.y, data_point) 
    158                             self.current_dataset.yaxis("Intensity", unit) 
    159                     elif key == u'Idev': 
    160                         if type(self.current_dataset) is plottable_2D: 
    161                             self.current_dataset.err_data = np.append(self.current_dataset.err_data, data_point) 
    162                         else: 
    163                             self.current_dataset.dy = np.append(self.current_dataset.dy, data_point) 
    164                     elif key == u'Q': 
    165                         self.current_dataset.xaxis("Q", unit) 
    166                         if type(self.current_dataset) is plottable_2D: 
    167                             self.current_dataset.q = np.append(self.current_dataset.q, data_point) 
    168                         else: 
    169                             self.current_dataset.x = np.append(self.current_dataset.x, data_point) 
    170                     elif key == u'Qy': 
    171                         self.current_dataset.yaxis("Q_y", unit) 
    172                         self.current_dataset.qy_data = np.append(self.current_dataset.qy_data, data_point) 
    173                     elif key == u'Qydev': 
    174                         self.current_dataset.dqy_data = np.append(self.current_dataset.dqy_data, data_point) 
    175                     elif key == u'Qx': 
    176                         self.current_dataset.xaxis("Q_x", unit) 
    177                         self.current_dataset.qx_data = np.append(self.current_dataset.qx_data, data_point) 
    178                     elif key == u'Qxdev': 
    179                         self.current_dataset.dqx_data = np.append(self.current_dataset.dqx_data, data_point) 
    180                     elif key == u'Mask': 
    181                         self.current_dataset.mask = np.append(self.current_dataset.mask, data_point) 
    182189 
    183190                    ## Sample Information 
     
    296303        ## Type cast data arrays to float64 and find min/max as appropriate 
    297304        for dataset in self.data2d: 
    298             dataset.data = np.delete(dataset.data, [0]) 
    299305            dataset.data = dataset.data.astype(np.float64) 
    300             dataset.err_data = np.delete(dataset.err_data, [0]) 
    301306            dataset.err_data = dataset.err_data.astype(np.float64) 
    302             dataset.mask = np.delete(dataset.mask, [0]) 
    303307            if dataset.qx_data is not None: 
    304                 dataset.qx_data = np.delete(dataset.qx_data, [0]) 
    305308                dataset.xmin = np.min(dataset.qx_data) 
    306309                dataset.xmax = np.max(dataset.qx_data) 
    307310                dataset.qx_data = dataset.qx_data.astype(np.float64) 
    308311            if dataset.dqx_data is not None: 
    309                 dataset.dqx_data = np.delete(dataset.dqx_data, [0]) 
    310312                dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
    311313            if dataset.qy_data is not None: 
    312                 dataset.qy_data = np.delete(dataset.qy_data, [0]) 
    313314                dataset.ymin = np.min(dataset.qy_data) 
    314315                dataset.ymax = np.max(dataset.qy_data) 
    315316                dataset.qy_data = dataset.qy_data.astype(np.float64) 
    316317            if dataset.dqy_data is not None: 
    317                 dataset.dqy_data = np.delete(dataset.dqy_data, [0]) 
    318318                dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
    319319            if dataset.q_data is not None: 
    320                 dataset.q_data = np.delete(dataset.q_data, [0]) 
    321320                dataset.q_data = dataset.q_data.astype(np.float64) 
    322321            zeros = np.ones(dataset.data.size, dtype=bool) 
     
    333332            except: 
    334333                dataset.q_data = None 
     334 
     335            if dataset.data.ndim == 2: 
     336                (n_rows, n_cols) = dataset.data.shape 
     337                dataset.y_bins = dataset.qy_data[0::n_rows] 
     338                dataset.x_bins = dataset.qx_data[:n_cols] 
     339                dataset.data = dataset.data.flatten() 
     340 
    335341            final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo) 
    336342            self.output.append(final_dataset) 
     
    338344        for dataset in self.data1d: 
    339345            if dataset.x is not None: 
    340                 dataset.x = np.delete(dataset.x, [0]) 
    341346                dataset.x = dataset.x.astype(np.float64) 
    342347                dataset.xmin = np.min(dataset.x) 
    343348                dataset.xmax = np.max(dataset.x) 
    344349            if dataset.y is not None: 
    345                 dataset.y = np.delete(dataset.y, [0]) 
    346350                dataset.y = dataset.y.astype(np.float64) 
    347351                dataset.ymin = np.min(dataset.y) 
    348352                dataset.ymax = np.max(dataset.y) 
    349353            if dataset.dx is not None: 
    350                 dataset.dx = np.delete(dataset.dx, [0]) 
    351354                dataset.dx = dataset.dx.astype(np.float64) 
    352355            if dataset.dxl is not None: 
    353                 dataset.dxl = np.delete(dataset.dxl, [0]) 
    354356                dataset.dxl = dataset.dxl.astype(np.float64) 
    355357            if dataset.dxw is not None: 
    356                 dataset.dxw = np.delete(dataset.dxw, [0]) 
    357358                dataset.dxw = dataset.dxw.astype(np.float64) 
    358359            if dataset.dy is not None: 
    359                 dataset.dy = np.delete(dataset.dy, [0]) 
    360360                dataset.dy = dataset.dy.astype(np.float64) 
    361361            final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo) 
  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    r1686a333 r5f26aa4  
    206206        # Go through each child in the parent element 
    207207        for node in dom: 
     208            attr = node.attrib 
     209            name = attr.get("name", "") 
     210            type = attr.get("type", "") 
    208211            # Get the element name and set the current names level 
    209212            tagname = node.tag.replace(self.base_ns, "") 
     
    223226                ## Recursion step to access data within the group 
    224227                self._parse_entry(node) 
     228                if tagname == "SASsample": 
     229                    self.current_datainfo.sample.name = name 
     230                elif tagname == "beam_size": 
     231                    self.current_datainfo.source.beam_size_name = name 
     232                elif tagname == "SAScollimation": 
     233                    self.collimation.name = name 
     234                elif tagname == "aperture": 
     235                    self.aperture.name = name 
     236                    self.aperture.type = type 
    225237                self.add_intermediate() 
    226238            else: 
     
    229241                ## If this is a dataset, store the data appropriately 
    230242                if tagname == 'Run': 
     243                    self.current_datainfo.run_name[data_point] = name 
    231244                    self.current_datainfo.run.append(data_point) 
    232245                elif tagname == 'Title': 
     
    369382                    self.process.notes.append(data_point) 
    370383                elif tagname == 'term' and self.parent_class == 'SASprocess': 
    371                     self.process.term.append(data_point) 
     384                    unit = attr.get("unit", "") 
     385                    dic = {} 
     386                    dic["name"] = name 
     387                    dic["value"] = data_point 
     388                    dic["unit"] = unit 
     389                    self.process.term.append(dic) 
    372390 
    373391                ## Transmission Spectrum 
     
    531549            self.current_datainfo.collimation.append(self.collimation) 
    532550            self.collimation = Collimation() 
    533         elif self.parent_class == 'SASaperture': 
     551        elif self.parent_class == 'aperture': 
    534552            self.collimation.aperture.append(self.aperture) 
    535553            self.aperture = Aperture() 
     
    646664        err_msg = None 
    647665        default_unit = None 
    648         if 'unit' in attr and attr.get('unit') is not None and not self.ns_list.ns_optional: 
     666        if not isinstance(node_value, float): 
     667            node_value = float(node_value) 
     668        if 'unit' in attr and attr.get('unit') is not None: 
    649669            try: 
    650670                local_unit = attr['unit'] 
    651                 if not isinstance(node_value, float): 
    652                     node_value = float(node_value) 
    653671                unitname = self.ns_list.current_level.get("unit", "") 
    654672                if "SASdetector" in self.names: 
     
    907925                self.write_node(point, "I", datainfo.y[i], 
    908926                                {'unit': datainfo.y_unit}) 
    909             if datainfo.dy != None and len(datainfo.dy) > i: 
     927            if datainfo.dy is not None and len(datainfo.dy) > i: 
    910928                self.write_node(point, "Idev", datainfo.dy[i], 
    911929                                {'unit': datainfo.y_unit}) 
    912             if datainfo.dx != None and len(datainfo.dx) > i: 
     930            if datainfo.dx is not None and len(datainfo.dx) > i: 
    913931                self.write_node(point, "Qdev", datainfo.dx[i], 
    914932                                {'unit': datainfo.x_unit}) 
    915             if datainfo.dxw != None and len(datainfo.dxw) > i: 
     933            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    916934                self.write_node(point, "dQw", datainfo.dxw[i], 
    917935                                {'unit': datainfo.x_unit}) 
    918             if datainfo.dxl != None and len(datainfo.dxl) > i: 
     936            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    919937                self.write_node(point, "dQl", datainfo.dxl[i], 
    920938                                {'unit': datainfo.x_unit}) 
     
    11841202                if isinstance(term, list): 
    11851203                    value = term['value'] 
     1204                    del term['value'] 
     1205                elif isinstance(term, dict): 
     1206                    value = term.get("value") 
    11861207                    del term['value'] 
    11871208                else: 
  • test/sasdataloader/test/utest_abs_reader.py

    rb699768 r5f26aa4  
    176176         
    177177        self.assertEqual(self.data.run[0], "1234") 
    178         self.assertEqual(self.data.meta_data['loader'], "CanSAS 1D") 
    179         self.assertEqual(len(self.data.errors), 0) 
     178        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    180179         
    181180        # Data 
     
    198197        self.assertEqual(self.data.sample.name, "my sample") 
    199198        self.assertEqual(self.data.sample.thickness_unit, 'mm') 
    200         self.assertEqual(self.data.sample.thickness, 1.03) 
    201          
    202         self.assertEqual(self.data.sample.transmission, 0.327) 
     199        self.assertAlmostEqual(self.data.sample.thickness, 1.03) 
     200         
     201        self.assertAlmostEqual(self.data.sample.transmission, 0.327) 
    203202         
    204203        self.assertEqual(self.data.sample.temperature_unit, 'C') 
     
    233232         
    234233        self.assertEqual(self.data.source.wavelength_max_unit, "nm") 
    235         self.assertEqual(self.data.source.wavelength_max, 1.0) 
     234        self.assertAlmostEqual(self.data.source.wavelength_max, 1.0) 
    236235        self.assertEqual(self.data.source.wavelength_min_unit, "nm") 
    237         self.assertEqual(self.data.source.wavelength_min, 0.22) 
     236        self.assertAlmostEqual(self.data.source.wavelength_min, 0.22) 
    238237        self.assertEqual(self.data.source.wavelength_spread_unit, "percent") 
    239238        self.assertEqual(self.data.source.wavelength_spread, 14.3) 
     
    248247            self.assertEqual(item.size_unit,'mm') 
    249248            self.assertEqual(item.distance_unit,'mm') 
    250              
     249 
    251250            if item.size.x==50 \ 
    252251                and item.distance==11000.0 \ 
     
    294293            self.assertTrue(item.date in ['04-Sep-2007 18:35:02', 
    295294                                          '03-SEP-2006 11:42:47']) 
     295            print item.term 
    296296            for t in item.term: 
    297297                if t['name']=="ABS:DSTAND" \ 
     
    345345        self.assertEqual(self.data.filename, filename) 
    346346        # The followed should not have been loaded 
    347         self.assertEqual(self.data.sample.thickness, 0.00103) 
     347        self.assertAlmostEqual(self.data.sample.thickness, 0.00103) 
    348348        # This one should 
    349         self.assertEqual(self.data.sample.transmission, 0.327) 
    350          
    351         self.assertEqual(self.data.meta_data['loader'], "CanSAS 1D") 
     349        self.assertAlmostEqual(self.data.sample.transmission, 0.327) 
     350         
     351        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D") 
    352352        print self.data.errors 
    353353        self.assertEqual(len(self.data.errors), 1) 
     
    385385 
    386386if __name__ == '__main__': 
    387     unittest.main(testRunner=unittest.TextTestRunner(verbosity=2)) 
     387    unittest.main() 
Note: See TracChangeset for help on using the changeset viewer.