Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sascalc/dataloader/file_reader_base_class.py

    r9b08354 rfee520ec  
    1616from .data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\ 
    1717    combine_data_info_with_plottable 
    18 from sas.sascalc.data_util.nxsunit import Converter 
    1918 
    2019logger = logging.getLogger(__name__) 
     
    3837                       "SasView cannot guarantee the accuracy of the data.") 
    3938 
    40  
    4139class FileReader(object): 
    4240    # String to describe the type of data this reader can load 
     
    4745    ext = ['.txt'] 
    4846    # Deprecated extensions 
    49     deprecated_extensions = ['.asc'] 
     47    deprecated_extensions = ['.asc', '.nxs'] 
    5048    # Bypass extension check and try to load anyway 
    5149    allow_all = False 
     
    10098                    if len(self.output) > 0: 
    10199                        # Sort the data that's been loaded 
    102                         self.convert_data_units() 
    103                         self.sort_data() 
     100                        self.sort_one_d_data() 
     101                        self.sort_two_d_data() 
    104102        else: 
    105103            msg = "Unable to find file at: {}\n".format(filepath) 
     
    142140        Returns the entire file as a string. 
    143141        """ 
     142        #return self.f_open.read() 
    144143        return decode(self.f_open.read()) 
    145144 
     
    167166        self.output.append(data_obj) 
    168167 
    169     def sort_data(self): 
     168    def sort_one_d_data(self): 
    170169        """ 
    171170        Sort 1D data along the X axis for consistency 
     
    175174                # Normalize the units for 
    176175                data.x_unit = self.format_unit(data.x_unit) 
    177                 data._xunit = data.x_unit 
    178176                data.y_unit = self.format_unit(data.y_unit) 
    179                 data._yunit = data.y_unit 
    180177                # Sort data by increasing x and remove 1st point 
    181178                ind = np.lexsort((data.y, data.x)) 
     
    206203                    data.ymin = np.min(data.y) 
    207204                    data.ymax = np.max(data.y) 
    208             elif isinstance(data, Data2D): 
    209                 # Normalize the units for 
    210                 data.Q_unit = self.format_unit(data.Q_unit) 
    211                 data.I_unit = self.format_unit(data.I_unit) 
    212                 data._xunit = data.Q_unit 
    213                 data._yunit = data.Q_unit 
    214                 data._zunit = data.I_unit 
    215                 data.data = data.data.astype(np.float64) 
    216                 data.qx_data = data.qx_data.astype(np.float64) 
    217                 data.xmin = np.min(data.qx_data) 
    218                 data.xmax = np.max(data.qx_data) 
    219                 data.qy_data = data.qy_data.astype(np.float64) 
    220                 data.ymin = np.min(data.qy_data) 
    221                 data.ymax = np.max(data.qy_data) 
    222                 data.q_data = np.sqrt(data.qx_data * data.qx_data 
    223                                          + data.qy_data * data.qy_data) 
    224                 if data.err_data is not None: 
    225                     data.err_data = data.err_data.astype(np.float64) 
    226                 if data.dqx_data is not None: 
    227                     data.dqx_data = data.dqx_data.astype(np.float64) 
    228                 if data.dqy_data is not None: 
    229                     data.dqy_data = data.dqy_data.astype(np.float64) 
    230                 if data.mask is not None: 
    231                     data.mask = data.mask.astype(dtype=bool) 
    232  
    233                 if len(data.data.shape) == 2: 
    234                     n_rows, n_cols = data.data.shape 
    235                     data.y_bins = data.qy_data[0::int(n_cols)] 
    236                     data.x_bins = data.qx_data[:int(n_cols)] 
    237                     data.data = data.data.flatten() 
    238                 data = self._remove_nans_in_data(data) 
    239                 if len(data.data) > 0: 
    240                     data.xmin = np.min(data.qx_data) 
    241                     data.xmax = np.max(data.qx_data) 
    242                     data.ymin = np.min(data.qy_data) 
    243                     data.ymax = np.max(data.qx_data) 
    244205 
    245206    @staticmethod 
     
    281242        return data 
    282243 
    283     @staticmethod 
    284     def set_default_1d_units(data): 
    285         """ 
    286         Set the x and y axes to the default 1D units 
    287         :param data: 1D data set 
    288         :return: 
    289         """ 
    290         data.xaxis(r"\rm{Q}", '1/A') 
    291         data.yaxis(r"\rm{Intensity}", "1/cm") 
    292         return data 
    293  
    294     @staticmethod 
    295     def set_default_2d_units(data): 
    296         """ 
    297         Set the x and y axes to the default 2D units 
    298         :param data: 2D data set 
    299         :return: 
    300         """ 
    301         data.xaxis("\\rm{Q_{x}}", '1/A') 
    302         data.yaxis("\\rm{Q_{y}}", '1/A') 
    303         data.zaxis("\\rm{Intensity}", "1/cm") 
    304         return data 
    305  
    306     def convert_data_units(self, default_q_unit="1/A"): 
    307         """ 
    308         Converts al; data to the sasview default of units of A^{-1} for Q and 
    309         cm^{-1} for I. 
    310         :param default_q_unit: The default Q unit used by Sasview 
    311         """ 
    312         convert_q = True 
    313         new_output = [] 
    314         for data in self.output: 
    315             if data.isSesans: 
    316                 new_output.append(data) 
    317                 continue 
    318             try: 
    319                 file_x_unit = data._xunit 
    320                 data_conv_x = Converter(file_x_unit) 
    321             except KeyError: 
    322                 logger.info("Unrecognized Q units in data file. No data " 
    323                             "conversion attempted") 
    324                 convert_q = False 
    325             try: 
    326  
    327                 if isinstance(data, Data1D): 
    328                         if convert_q: 
    329                             data.x = data_conv_x(data.x, units=default_q_unit) 
    330                             data._xunit = default_q_unit 
    331                             data.x_unit = default_q_unit 
    332                             if data.dx is not None: 
    333                                 data.dx = data_conv_x(data.dx, 
    334                                                       units=default_q_unit) 
    335                             if data.dxl is not None: 
    336                                 data.dxl = data_conv_x(data.dxl, 
    337                                                        units=default_q_unit) 
    338                             if data.dxw is not None: 
    339                                 data.dxw = data_conv_x(data.dxw, 
    340                                                        units=default_q_unit) 
    341                 elif isinstance(data, Data2D): 
    342                     if convert_q: 
    343                         data.qx_data = data_conv_x(data.qx_data, 
    344                                                    units=default_q_unit) 
    345                         if data.dqx_data is not None: 
    346                             data.dqx_data = data_conv_x(data.dqx_data, 
    347                                                         units=default_q_unit) 
    348                         try: 
    349                             file_y_unit = data._yunit 
    350                             data_conv_y = Converter(file_y_unit) 
    351                             data.qy_data = data_conv_y(data.qy_data, 
    352                                                        units=default_q_unit) 
    353                             if data.dqy_data is not None: 
    354                                 data.dqy_data = data_conv_y(data.dqy_data, 
    355                                                             units=default_q_unit) 
    356                         except KeyError: 
    357                             logger.info("Unrecognized Qy units in data file. No" 
    358                                         " data conversion attempted") 
    359             except KeyError: 
    360                 message = "Unable to convert Q units from {0} to 1/A." 
    361                 message.format(default_q_unit) 
    362                 data.errors.append(message) 
    363             new_output.append(data) 
    364         self.output = new_output 
     244    def sort_two_d_data(self): 
     245        for dataset in self.output: 
     246            if isinstance(dataset, Data2D): 
     247                # Normalize the units for 
     248                dataset.x_unit = self.format_unit(dataset.Q_unit) 
     249                dataset.y_unit = self.format_unit(dataset.I_unit) 
     250                dataset.data = dataset.data.astype(np.float64) 
     251                dataset.qx_data = dataset.qx_data.astype(np.float64) 
     252                dataset.xmin = np.min(dataset.qx_data) 
     253                dataset.xmax = np.max(dataset.qx_data) 
     254                dataset.qy_data = dataset.qy_data.astype(np.float64) 
     255                dataset.ymin = np.min(dataset.qy_data) 
     256                dataset.ymax = np.max(dataset.qy_data) 
     257                dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data 
     258                                         + dataset.qy_data * dataset.qy_data) 
     259                if dataset.err_data is not None: 
     260                    dataset.err_data = dataset.err_data.astype(np.float64) 
     261                if dataset.dqx_data is not None: 
     262                    dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
     263                if dataset.dqy_data is not None: 
     264                    dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
     265                if dataset.mask is not None: 
     266                    dataset.mask = dataset.mask.astype(dtype=bool) 
     267 
     268                if len(dataset.data.shape) == 2: 
     269                    n_rows, n_cols = dataset.data.shape 
     270                    dataset.y_bins = dataset.qy_data[0::int(n_cols)] 
     271                    dataset.x_bins = dataset.qx_data[:int(n_cols)] 
     272                dataset.data = dataset.data.flatten() 
     273                dataset = self._remove_nans_in_data(dataset) 
     274                if len(dataset.data) > 0: 
     275                    dataset.xmin = np.min(dataset.qx_data) 
     276                    dataset.xmax = np.max(dataset.qx_data) 
     277                    dataset.ymin = np.min(dataset.qy_data) 
     278                    dataset.ymax = np.max(dataset.qy_data) 
    365279 
    366280    def format_unit(self, unit=None): 
     
    453367                    self.current_dataset.qy_data)) 
    454368            if has_error_dy: 
    455                 self.current_dataset.err_data = self.current_dataset.err_data[ 
    456                     x != 0] 
     369                self.current_dataset.err_data = self.current_dataset.err_data[x != 0] 
    457370            if has_error_dqx: 
    458                 self.current_dataset.dqx_data = self.current_dataset.dqx_data[ 
    459                     x != 0] 
     371                self.current_dataset.dqx_data = self.current_dataset.dqx_data[x != 0] 
    460372            if has_error_dqy: 
    461                 self.current_dataset.dqy_data = self.current_dataset.dqy_data[ 
    462                     x != 0] 
     373                self.current_dataset.dqy_data = self.current_dataset.dqy_data[x != 0] 
    463374            if has_mask: 
    464375                self.current_dataset.mask = self.current_dataset.mask[x != 0] 
Note: See TracChangeset for help on using the changeset viewer.