Changeset 11288e7c in sasview


Ignore:
Timestamp:
Sep 27, 2017 10:48:58 AM (5 years ago)
Author:
GitHub <noreply@…>
Parents:
ad476d1 (diff), 38a1e63 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Tim Snow <tim.snow@…> (09/27/17 10:48:58)
git-committer:
GitHub <noreply@…> (09/27/17 10:48:58)
Message:

Merge 38a1e63505ecad9decb390379725c099ed38f4d0 into ad476d193c0864f278ac1d0d3573c4836631790c

Files:
12 edited
2 moved

Legend:

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

    r17e257b5 rdeaa0c6  
    11761176        final_dataset.yaxis(data._yaxis, data._yunit) 
    11771177        final_dataset.zaxis(data._zaxis, data._zunit) 
    1178         final_dataset.x_bins = data.x_bins 
    1179         final_dataset.y_bins = data.y_bins 
     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)] 
    11801182    else: 
    11811183        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

    rae69c690 rdeaa0c6  
    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) 
    169174 
    170175    def format_unit(self, unit=None): 
     
    191196        self.output = [] 
    192197 
    193     def remove_empty_q_values(self, has_error_dx=False, has_error_dy=False, 
    194                               has_error_dxl=False, has_error_dxw=False): 
     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): 
    195208        """ 
    196209        Remove any point where Q == 0 
    197210        """ 
    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] 
     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] 
    209271 
    210272    def reset_data_list(self, no_lines=0): 
  • src/sas/sascalc/dataloader/readers/abs_reader.py

    rad92c5a rffb6474  
    109109                # Sample thickness in mm 
    110110                try: 
    111                     value = float(line_toks[5]) 
     111                    value = float(line_toks[5][:-1]) 
    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(True, True) 
     204        self.remove_empty_q_values() 
    205205 
    206206        # Sanity check 
  • src/sas/sascalc/dataloader/readers/ascii_reader.py

    rf994e8b1 r7b07fbe  
    156156            raise FileContentsException(msg) 
    157157 
    158         self.remove_empty_q_values(has_error_dx, has_error_dy) 
     158        self.remove_empty_q_values() 
    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

    rae69c690 r62160509  
    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  
    111106        try: 
    112107            # Raises FileContentsException 
    113108            self.load_file_and_schema(xml_file, schema_path) 
    114             self.current_datainfo = DataInfo() 
    115             # Raises FileContentsException if file doesn't meet CanSAS schema 
     109            # Parse each SASentry 
     110            entry_list = self.xmlroot.xpath('/ns:SASroot/ns:SASentry', 
     111                                            namespaces={ 
     112                                                'ns': self.cansas_defaults.get( 
     113                                                    "ns") 
     114                                            }) 
    116115            self.is_cansas(self.extension) 
    117             self.invalid = False # If we reach this point then file must be valid CanSAS 
    118  
    119             # Parse each SASentry 
    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") 
    125116            self.set_processing_instructions() 
    126  
    127117            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 
    131118                self._parse_entry(entry) 
    132119                self.data_cleanup() 
     
    150137                    invalid_xml = self.find_invalid_xml() 
    151138                    if invalid_xml != "": 
     139                        basename, _ = os.path.splitext( 
     140                            os.path.basename(self.f_open.name)) 
    152141                        invalid_xml = INVALID_XML.format(basename + self.extension) + invalid_xml 
    153142                        raise DataReaderException(invalid_xml) # Handled by base class 
     
    164153        except Exception as e: # Convert all other exceptions to FileContentsExceptions 
    165154            raise FileContentsException(e.message) 
    166  
     155        finally: 
     156            if not self.f_open.closed: 
     157                self.f_open.close() 
    167158 
    168159    def load_file_and_schema(self, xml_file, schema_path=""): 
     
    209200        if not self._is_call_local() and not recurse: 
    210201            self.reset_state() 
     202        if not recurse: 
     203            self.current_datainfo = DataInfo() 
     204            # Raises FileContentsException if file doesn't meet CanSAS schema 
     205            self.invalid = False 
     206            # Look for a SASentry 
    211207            self.data = [] 
    212             self.current_datainfo = DataInfo() 
     208            self.parent_class = "SASentry" 
    213209            self.names.append("SASentry") 
    214             self.parent_class = "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 
    215216        # Create an empty dataset if no data has been passed to the reader 
    216217        if self.current_dataset is None: 
    217             self.current_dataset = plottable_1D(np.empty(0), np.empty(0), 
    218                 np.empty(0), np.empty(0)) 
     218            self._initialize_new_data_set(dom) 
    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 == "fitting_plug_in" or tagname == "pr_inversion" or tagname == "invariant": 
     230            if tagname in ["fitting_plug_in", "pr_inversion", "invariant", "corfunc"]: 
    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) 
    260261                if isinstance(self.current_dataset, plottable_2D): 
    261262                    data_point = node.text 
     
    502503            self.sort_two_d_data() 
    503504            self.reset_data_list() 
    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 
     505            return self.output[0], None 
    522506 
    523507    def _is_call_local(self): 
     
    553537            self.aperture = Aperture() 
    554538        elif self.parent_class == 'SASdata': 
    555             self._check_for_empty_resolution() 
    556539            self.data.append(self.current_dataset) 
    557540 
     
    609592        if 'unit' in attr and attr.get('unit') is not None: 
    610593            try: 
    611                 local_unit = attr['unit'] 
     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 
    612602                unitname = self.ns_list.current_level.get("unit", "") 
    613603                if "SASdetector" in self.names: 
     
    665655        return node_value, value_unit 
    666656 
    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  
    698657    def _initialize_new_data_set(self, node=None): 
    699658        if node is not None: 
  • src/sas/sasgui/perspectives/corfunc/corfunc_state.py

    r2a399ca r1fa4f736  
    289289                namespaces={'ns': CANSAS_NS}) 
    290290            for entry in entry_list: 
    291                 sas_entry, _ = self._parse_entry(entry) 
    292291                corstate = self._parse_state(entry) 
    293292 
    294293                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/basepage.py

    rf80b416e r53b8266  
    1515import traceback 
    1616 
     17from Queue import Queue 
     18from threading import Thread 
    1719from collections import defaultdict 
    1820from wx.lib.scrolledpanel import ScrolledPanel 
     
    241243        self.set_layout() 
    242244 
     245        # Setting up a thread for the fitting 
     246        self.threaded_draw_queue = Queue() 
     247 
     248        self.draw_worker_thread = Thread(target = self._threaded_draw_worker, 
     249                                         args = (self.threaded_draw_queue,)) 
     250        self.draw_worker_thread.setDaemon(True) 
     251        self.draw_worker_thread.start() 
     252 
     253        # And a home for the thread submission times 
     254        self.last_time_fit_submitted = 0.00 
     255 
    243256    def set_index_model(self, index): 
    244257        """ 
     
    16931706        :param chisqr: update chisqr value [bool] 
    16941707        """ 
    1695         wx.CallAfter(self._draw_model_after, update_chisqr, source) 
     1708        self.threaded_draw_queue.put([copy.copy(update_chisqr), copy.copy(source)]) 
     1709 
     1710    def _threaded_draw_worker(self, threaded_draw_queue): 
     1711        while True: 
     1712            # sit and wait for the next task 
     1713            next_task = threaded_draw_queue.get() 
     1714 
     1715            # sleep for 1/10th second in case some other tasks accumulate 
     1716            time.sleep(0.1) 
     1717 
     1718            # skip all intermediate tasks 
     1719            while self.threaded_draw_queue.qsize() > 0: 
     1720                self.threaded_draw_queue.task_done() 
     1721                next_task = self.threaded_draw_queue.get() 
     1722 
     1723            # and finally, do the task 
     1724            self._draw_model_after(*next_task) 
     1725            threaded_draw_queue.task_done() 
    16961726 
    16971727    def _draw_model_after(self, update_chisqr=True, source='model'): 
     
    17161746            toggle_mode_on = self.model_view.IsEnabled() 
    17171747            is_2d = self._is_2D() 
     1748 
    17181749            self._manager.draw_model(self.model, 
    17191750                                     data=self.data, 
  • src/sas/sasgui/perspectives/fitting/fitpage.py

    r13374be r48154abb  
    20422042            # Save state_fit 
    20432043            self.save_current_state_fit() 
     2044            self.onSmear(None) 
     2045            self._onDraw(None) 
    20442046        except: 
    20452047            self._show_combox_helper() 
  • src/sas/sasgui/perspectives/fitting/pagestate.py

    rda9b239 r1fa4f736  
    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 
    13031299                        fitstate = self._parse_state(entry) 
    1304  
    13051300                        # state could be None when .svs file is loaded 
    13061301                        # in this case, skip appending to output 
    13071302                        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

    ra9f9ca4 r9804394  
    10731073        """ 
    10741074 
    1075         model_map = {} 
     1075        init_map = {} 
     1076        final_map = {} 
    10761077        if fit.fit_panel.sim_page is None: 
    10771078            fit.fit_panel.add_sim_page() 
     
    10871088                save_id = self._format_id(save_id) 
    10881089                if save_id == model_id: 
    1089                     model_map[saved_model.pop('fit_page_source')] = \ 
    1090                         model[3].name 
     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 
    10911093                    check = bool(saved_model.pop('checked')) 
    10921094                    sim_page.model_list[i][0].SetValue(check) 
     
    11061108                param = item.pop('param_cbox') 
    11071109                equality = item.pop('egal_txt') 
    1108                 for key, value in model_map.iteritems(): 
    1109                     model_cbox.replace(key, value) 
    1110                     constraint_value.replace(key, value) 
     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) 
    11111116 
    11121117                sim_page.constraints_list[index][0].SetValue(model_cbox) 
  • src/sas/sasgui/perspectives/invariant/invariant_state.py

    r7432acb r1fa4f736  
    728728 
    729729                for entry in entry_list: 
    730  
    731                     sas_entry, _ = self._parse_entry(entry) 
    732730                    invstate = self._parse_state(entry) 
    733  
    734731                    # invstate could be None when .svs file is loaded 
    735732                    # in this case, skip appending to output 
    736733                    if invstate is not None: 
     734                        sas_entry, _ = self._parse_entry(entry) 
    737735                        sas_entry.meta_data['invstate'] = invstate 
    738736                        sas_entry.filename = invstate.file 
  • src/sas/sasgui/perspectives/pr/inversion_state.py

    ra0e6b1b r1fa4f736  
    472472 
    473473                for entry in entry_list: 
    474                     sas_entry, _ = self._parse_entry(entry) 
    475474                    prstate = self._parse_prstate(entry) 
    476475                    #prstate could be None when .svs file is loaded 
    477476                    #in this case, skip appending to output 
    478477                    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.