Changes in / [66000ae:dba8557] in sasview


Ignore:
Location:
src/sas
Files:
2 added
2 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/dataloader/data_info.py

    rdeaa0c6 r17e257b5  
    11761176        final_dataset.yaxis(data._yaxis, data._yunit) 
    11771177        final_dataset.zaxis(data._zaxis, data._zunit) 
    1178         if len(data.data.shape) == 2: 
    1179             n_rows, n_cols = data.data.shape 
    1180             final_dataset.y_bins = data.qy_data[0::int(n_cols)] 
    1181             final_dataset.x_bins = data.qx_data[:int(n_cols)] 
     1178        final_dataset.x_bins = data.x_bins 
     1179        final_dataset.y_bins = data.y_bins 
    11821180    else: 
    11831181        return_string = "Should Never Happen: _combine_data_info_with_plottable input is not a plottable1d or " + \ 

  • src/sas/sascalc/dataloader/file_reader_base_class.py

    rdeaa0c6 rae69c690  
    167167                    dataset.x_bins = dataset.qx_data[:int(n_cols)] 
    168168                dataset.data = dataset.data.flatten() 
    169                 if len(dataset.data) > 0: 
    170                     dataset.xmin = np.min(dataset.qx_data) 
    171                     dataset.xmax = np.max(dataset.qx_data) 
    172                     dataset.ymin = np.min(dataset.qy_data) 
    173                     dataset.ymax = np.max(dataset.qx_data) 
    174169 
    175170    def format_unit(self, unit=None): 
    … …  
    196191        self.output = [] 
    197192 
    198     def data_cleanup(self): 
    199         """ 
    200         Clean up the data sets and refresh everything 
    201         :return: None 
    202         """ 
    203         self.remove_empty_q_values() 
    204         self.send_to_output()  # Combine datasets with DataInfo 
    205         self.current_datainfo = DataInfo()  # Reset DataInfo 
    206  
    207     def remove_empty_q_values(self): 
     193    def remove_empty_q_values(self, has_error_dx=False, has_error_dy=False, 
     194                              has_error_dxl=False, has_error_dxw=False): 
    208195        """ 
    209196        Remove any point where Q == 0 
    210197        """ 
    211         if isinstance(self.current_dataset, plottable_1D): 
    212             # Booleans for resolutions 
    213             has_error_dx = self.current_dataset.dx is not None 
    214             has_error_dxl = self.current_dataset.dxl is not None 
    215             has_error_dxw = self.current_dataset.dxw is not None 
    216             has_error_dy = self.current_dataset.dy is not None 
    217             # Create arrays of zeros for non-existent resolutions 
    218             if has_error_dxw and not has_error_dxl: 
    219                 array_size = self.current_dataset.dxw.size - 1 
    220                 self.current_dataset.dxl = np.append(self.current_dataset.dxl, 
    221                                                     np.zeros([array_size])) 
    222                 has_error_dxl = True 
    223             elif has_error_dxl and not has_error_dxw: 
    224                 array_size = self.current_dataset.dxl.size - 1 
    225                 self.current_dataset.dxw = np.append(self.current_dataset.dxw, 
    226                                                     np.zeros([array_size])) 
    227                 has_error_dxw = True 
    228             elif not has_error_dxl and not has_error_dxw and not has_error_dx: 
    229                 array_size = self.current_dataset.x.size - 1 
    230                 self.current_dataset.dx = np.append(self.current_dataset.dx, 
    231                                                     np.zeros([array_size])) 
    232                 has_error_dx = True 
    233             if not has_error_dy: 
    234                 array_size = self.current_dataset.y.size - 1 
    235                 self.current_dataset.dy = np.append(self.current_dataset.dy, 
    236                                                     np.zeros([array_size])) 
    237                 has_error_dy = True 
    238  
    239             # Remove points where q = 0 
    240             x = self.current_dataset.x 
    241             self.current_dataset.x = self.current_dataset.x[x != 0] 
    242             self.current_dataset.y = self.current_dataset.y[x != 0] 
    243             if has_error_dy: 
    244                 self.current_dataset.dy = self.current_dataset.dy[x != 0] 
    245             if has_error_dx: 
    246                 self.current_dataset.dx = self.current_dataset.dx[x != 0] 
    247             if has_error_dxl: 
    248                 self.current_dataset.dxl = self.current_dataset.dxl[x != 0] 
    249             if has_error_dxw: 
    250                 self.current_dataset.dxw = self.current_dataset.dxw[x != 0] 
    251         elif isinstance(self.current_dataset, plottable_2D): 
    252             has_error_dqx = self.current_dataset.dqx_data is not None 
    253             has_error_dqy = self.current_dataset.dqy_data is not None 
    254             has_error_dy = self.current_dataset.err_data is not None 
    255             has_mask = self.current_dataset.mask is not None 
    256             x = self.current_dataset.qx_data 
    257             self.current_dataset.data = self.current_dataset.data[x != 0] 
    258             self.current_dataset.qx_data = self.current_dataset.qx_data[x != 0] 
    259             self.current_dataset.qy_data = self.current_dataset.qy_data[x != 0] 
    260             self.current_dataset.q_data = np.sqrt( 
    261                 np.square(self.current_dataset.qx_data) + np.square( 
    262                     self.current_dataset.qy_data)) 
    263             if has_error_dy: 
    264                 self.current_dataset.err_data = self.current_dataset.err_data[x != 0] 
    265             if has_error_dqx: 
    266                 self.current_dataset.dqx_data = self.current_dataset.dqx_data[x != 0] 
    267             if has_error_dqy: 
    268                 self.current_dataset.dqy_data = self.current_dataset.dqy_data[x != 0] 
    269             if has_mask: 
    270                 self.current_dataset.mask = self.current_dataset.mask[x != 0] 
     198        x = self.current_dataset.x 
     199        self.current_dataset.x = self.current_dataset.x[x != 0] 
     200        self.current_dataset.y = self.current_dataset.y[x != 0] 
     201        if has_error_dy: 
     202            self.current_dataset.dy = self.current_dataset.dy[x != 0] 
     203        if has_error_dx: 
     204            self.current_dataset.dx = self.current_dataset.dx[x != 0] 
     205        if has_error_dxl: 
     206            self.current_dataset.dxl = self.current_dataset.dxl[x != 0] 
     207        if has_error_dxw: 
     208            self.current_dataset.dxw = self.current_dataset.dxw[x != 0] 
    271209 
    272210    def reset_data_list(self, no_lines=0): 

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

    rffb6474 rad92c5a  
    109109                # Sample thickness in mm 
    110110                try: 
    111                     value = float(line_toks[5][:-1]) 
     111                    value = float(line_toks[5]) 
    112112                    if self.has_converter and \ 
    113113                            self.current_datainfo.sample.thickness_unit != 'cm': 
    … …  
    202202                is_data_started = True 
    203203 
    204         self.remove_empty_q_values() 
     204        self.remove_empty_q_values(True, True) 
    205205 
    206206        # Sanity check 

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

    r7b07fbe rf994e8b1  
    156156            raise FileContentsException(msg) 
    157157 
    158         self.remove_empty_q_values() 
     158        self.remove_empty_q_values(has_error_dx, has_error_dy) 
    159159        self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
    160160        self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 

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

    r62160509 rae69c690  
    104104            xml_file = self.f_open.name 
    105105        # We don't sure f_open since lxml handles opnening/closing files 
     106        if not self.f_open.closed: 
     107            self.f_open.close() 
     108 
     109        basename, _ = os.path.splitext(os.path.basename(xml_file)) 
     110 
    106111        try: 
    107112            # Raises FileContentsException 
    108113            self.load_file_and_schema(xml_file, schema_path) 
     114            self.current_datainfo = DataInfo() 
     115            # Raises FileContentsException if file doesn't meet CanSAS schema 
     116            self.is_cansas(self.extension) 
     117            self.invalid = False # If we reach this point then file must be valid CanSAS 
     118 
    109119            # Parse each SASentry 
    110             entry_list = self.xmlroot.xpath('/ns:SASroot/ns:SASentry', 
    111                                             namespaces={ 
    112                                                 'ns': self.cansas_defaults.get( 
    113                                                     "ns") 
    114                                             }) 
    115             self.is_cansas(self.extension) 
     120            entry_list = self.xmlroot.xpath('/ns:SASroot/ns:SASentry', namespaces={ 
     121                'ns': self.cansas_defaults.get("ns") 
     122            }) 
     123            # Look for a SASentry 
     124            self.names.append("SASentry") 
    116125            self.set_processing_instructions() 
     126 
    117127            for entry in entry_list: 
     128                self.current_datainfo.filename = basename + self.extension 
     129                self.current_datainfo.meta_data["loader"] = "CanSAS XML 1D" 
     130                self.current_datainfo.meta_data[PREPROCESS] = self.processing_instructions 
    118131                self._parse_entry(entry) 
    119132                self.data_cleanup() 
    … …  
    137150                    invalid_xml = self.find_invalid_xml() 
    138151                    if invalid_xml != "": 
    139                         basename, _ = os.path.splitext( 
    140                             os.path.basename(self.f_open.name)) 
    141152                        invalid_xml = INVALID_XML.format(basename + self.extension) + invalid_xml 
    142153                        raise DataReaderException(invalid_xml) # Handled by base class 
    … …  
    153164        except Exception as e: # Convert all other exceptions to FileContentsExceptions 
    154165            raise FileContentsException(e.message) 
    155         finally: 
    156             if not self.f_open.closed: 
    157                 self.f_open.close() 
     166 
    158167 
    159168    def load_file_and_schema(self, xml_file, schema_path=""): 
    … …  
    200209        if not self._is_call_local() and not recurse: 
    201210            self.reset_state() 
    202         if not recurse: 
     211            self.data = [] 
    203212            self.current_datainfo = DataInfo() 
    204             # Raises FileContentsException if file doesn't meet CanSAS schema 
    205             self.invalid = False 
    206             # Look for a SASentry 
    207             self.data = [] 
     213            self.names.append("SASentry") 
    208214            self.parent_class = "SASentry" 
    209             self.names.append("SASentry") 
    210             self.current_datainfo.meta_data["loader"] = "CanSAS XML 1D" 
    211             self.current_datainfo.meta_data[ 
    212                 PREPROCESS] = self.processing_instructions 
    213         if self._is_call_local() and not recurse: 
    214             basename, _ = os.path.splitext(os.path.basename(self.f_open.name)) 
    215             self.current_datainfo.filename = basename + self.extension 
    216215        # Create an empty dataset if no data has been passed to the reader 
    217216        if self.current_dataset is None: 
    218             self._initialize_new_data_set(dom) 
     217            self.current_dataset = plottable_1D(np.empty(0), np.empty(0), 
     218                np.empty(0), np.empty(0)) 
    219219        self.base_ns = "{" + CANSAS_NS.get(self.cansas_version).get("ns") + "}" 
    220220 
    … …  
    228228            tagname_original = tagname 
    229229            # Skip this iteration when loading in save state information 
    230             if tagname in ["fitting_plug_in", "pr_inversion", "invariant", "corfunc"]: 
     230            if tagname == "fitting_plug_in" or tagname == "pr_inversion" or tagname == "invariant": 
    231231                continue 
    232232            # Get where to store content 
    … …  
    258258                self._add_intermediate() 
    259259            else: 
    260                 # TODO: Clean this up to make it faster (fewer if/elifs) 
    261260                if isinstance(self.current_dataset, plottable_2D): 
    262261                    data_point = node.text 
    … …  
    503502            self.sort_two_d_data() 
    504503            self.reset_data_list() 
    505             return self.output[0], None 
     504            empty = None 
     505            return self.output[0], empty 
     506 
     507    def data_cleanup(self): 
     508        """ 
     509        Clean up the data sets and refresh everything 
     510        :return: None 
     511        """ 
     512        has_error_dx = self.current_dataset.dx is not None 
     513        has_error_dxl = self.current_dataset.dxl is not None 
     514        has_error_dxw = self.current_dataset.dxw is not None 
     515        has_error_dy = self.current_dataset.dy is not None 
     516        self.remove_empty_q_values(has_error_dx=has_error_dx, 
     517                                   has_error_dxl=has_error_dxl, 
     518                                   has_error_dxw=has_error_dxw, 
     519                                   has_error_dy=has_error_dy) 
     520        self.send_to_output()  # Combine datasets with DataInfo 
     521        self.current_datainfo = DataInfo()  # Reset DataInfo 
    506522 
    507523    def _is_call_local(self): 
    … …  
    537553            self.aperture = Aperture() 
    538554        elif self.parent_class == 'SASdata': 
     555            self._check_for_empty_resolution() 
    539556            self.data.append(self.current_dataset) 
    540557 
    … …  
    592609        if 'unit' in attr and attr.get('unit') is not None: 
    593610            try: 
    594                 unit = attr['unit'] 
    595                 unit_list = unit.split("|") 
    596                 if len(unit_list) > 1: 
    597                     self.current_dataset.xaxis(unit_list[0].strip(), 
    598                                                unit_list[1].strip()) 
    599                     local_unit = unit_list[1] 
    600                 else: 
    601                     local_unit = unit 
     611                local_unit = attr['unit'] 
    602612                unitname = self.ns_list.current_level.get("unit", "") 
    603613                if "SASdetector" in self.names: 
    … …  
    655665        return node_value, value_unit 
    656666 
     667    def _check_for_empty_resolution(self): 
     668        """ 
     669        a method to check all resolution data sets are the same size as I and q 
     670        """ 
     671        dql_exists = False 
     672        dqw_exists = False 
     673        dq_exists = False 
     674        di_exists = False 
     675        if self.current_dataset.dxl is not None: 
     676            dql_exists = True 
     677        if self.current_dataset.dxw is not None: 
     678            dqw_exists = True 
     679        if self.current_dataset.dx is not None: 
     680            dq_exists = True 
     681        if self.current_dataset.dy is not None: 
     682            di_exists = True 
     683        if dqw_exists and not dql_exists: 
     684            array_size = self.current_dataset.dxw.size 
     685            self.current_dataset.dxl = np.zeros(array_size) 
     686        elif dql_exists and not dqw_exists: 
     687            array_size = self.current_dataset.dxl.size 
     688            self.current_dataset.dxw = np.zeros(array_size) 
     689        elif not dql_exists and not dqw_exists and not dq_exists: 
     690            array_size = self.current_dataset.x.size 
     691            self.current_dataset.dx = np.append(self.current_dataset.dx, 
     692                                                np.zeros([array_size])) 
     693        if not di_exists: 
     694            array_size = self.current_dataset.y.size 
     695            self.current_dataset.dy = np.append(self.current_dataset.dy, 
     696                                                np.zeros([array_size])) 
     697 
    657698    def _initialize_new_data_set(self, node=None): 
    658699        if node is not None: 

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

    r1fa4f736 r2a399ca  
    289289                namespaces={'ns': CANSAS_NS}) 
    290290            for entry in entry_list: 
     291                sas_entry, _ = self._parse_entry(entry) 
    291292                corstate = self._parse_state(entry) 
    292293 
    293294                if corstate is not None: 
    294                     sas_entry, _ = self._parse_entry(entry) 
    295295                    sas_entry.meta_data['corstate'] = corstate 
    296296                    sas_entry.filename = corstate.file 

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

    r48154abb r79e6a33  
    20422042            # Save state_fit 
    20432043            self.save_current_state_fit() 
    2044             self.onSmear(None) 
    2045             self._onDraw(None) 
    20462044        except: 
    20472045            self._show_combox_helper() 

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

    r1fa4f736 rda9b239  
    12971297                                            namespaces={'ns': CANSAS_NS}) 
    12981298                    for entry in entry_list: 
     1299                        try: 
     1300                            sas_entry, _ = self._parse_save_state_entry(entry) 
     1301                        except: 
     1302                            raise 
    12991303                        fitstate = self._parse_state(entry) 
     1304 
    13001305                        # state could be None when .svs file is loaded 
    13011306                        # in this case, skip appending to output 
    13021307                        if fitstate is not None: 
    1303                             try: 
    1304                                 sas_entry, _ = self._parse_save_state_entry( 
    1305                                     entry) 
    1306                             except: 
    1307                                 raise 
    13081308                            sas_entry.meta_data['fitstate'] = fitstate 
    13091309                            sas_entry.filename = fitstate.file 

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

    rf73b47c ra9f9ca4  
    10731073        """ 
    10741074 
    1075         init_map = {} 
    1076         final_map = {} 
     1075        model_map = {} 
    10771076        if fit.fit_panel.sim_page is None: 
    10781077            fit.fit_panel.add_sim_page() 
    … …  
    10881087                save_id = self._format_id(save_id) 
    10891088                if save_id == model_id: 
    1090                     inter_id = str(i) + str(i) + str(i) + str(i) + str(i) 
    1091                     init_map[saved_model.pop('fit_page_source')] = inter_id 
    1092                     final_map[inter_id] = model[3].name 
     1089                    model_map[saved_model.pop('fit_page_source')] = \ 
     1090                        model[3].name 
    10931091                    check = bool(saved_model.pop('checked')) 
    10941092                    sim_page.model_list[i][0].SetValue(check) 
    … …  
    11081106                param = item.pop('param_cbox') 
    11091107                equality = item.pop('egal_txt') 
    1110                 for key, value in init_map.items(): 
    1111                     model_cbox = model_cbox.replace(key, value) 
    1112                     constraint_value = constraint_value.replace(key, value) 
    1113                 for key, value in final_map.items(): 
    1114                     model_cbox = model_cbox.replace(key, value) 
    1115                     constraint_value = constraint_value.replace(key, value) 
     1108                for key, value in model_map.iteritems(): 
     1109                    model_cbox.replace(key, value) 
     1110                    constraint_value.replace(key, value) 
    11161111 
    11171112                sim_page.constraints_list[index][0].SetValue(model_cbox) 

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

    r1fa4f736 r7432acb  
    728728 
    729729                for entry in entry_list: 
     730 
     731                    sas_entry, _ = self._parse_entry(entry) 
    730732                    invstate = self._parse_state(entry) 
     733 
    731734                    # invstate could be None when .svs file is loaded 
    732735                    # in this case, skip appending to output 
    733736                    if invstate is not None: 
    734                         sas_entry, _ = self._parse_entry(entry) 
    735737                        sas_entry.meta_data['invstate'] = invstate 
    736738                        sas_entry.filename = invstate.file 

  • src/sas/sasgui/perspectives/pr/inversion_state.py

    r1fa4f736 ra0e6b1b  
    472472 
    473473                for entry in entry_list: 
     474                    sas_entry, _ = self._parse_entry(entry) 
    474475                    prstate = self._parse_prstate(entry) 
    475476                    #prstate could be None when .svs file is loaded 
    476477                    #in this case, skip appending to output 
    477478                    if prstate is not None: 
    478                         sas_entry, _ = self._parse_entry(entry) 
    479479                        sas_entry.meta_data['prstate'] = prstate 
    480480                        sas_entry.filename = prstate.file 
Note: See TracChangeset for help on using the changeset viewer.