Changeset 8e15dce in sasview for src/sas


Ignore:
Timestamp:
May 10, 2017 9:39:17 AM (8 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.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
e0ebd56
Parents:
914c49d5
Message:

Modified manipulations to clarify what is needed. Save sliced data as txt by default, instead of xml, to speed up data process. numpy → np.

Location:
src/sas
Files:
2 edited

Legend:

Unmodified
Added
Removed

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

    r3e5648b r8e15dce  
    1414#TODO: copy the meta data from the 2D object to the resulting 1D object 
    1515import math 
    16 import numpy 
     16import numpy as np 
    1717 
    1818#from data_info import plottable_2D 
    … …  
    8282    if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None: 
    8383        raise ValueError, "Can't convert this data: data=None..." 
    84     new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
    85     new_y = numpy.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
     84    new_x = np.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
     85    new_y = np.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
    8686    new_y = new_y.swapaxes(0, 1) 
    8787 
    … …  
    8989    qx_data = new_x.flatten() 
    9090    qy_data = new_y.flatten() 
    91     q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
    92     if data2d.err_data is None or numpy.any(data2d.err_data <= 0): 
    93         new_err_data = numpy.sqrt(numpy.abs(new_data)) 
     91    q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
     92    if data2d.err_data is None or np.any(data2d.err_data <= 0): 
     93        new_err_data = np.sqrt(np.abs(new_data)) 
    9494    else: 
    9595        new_err_data = data2d.err_data.flatten() 
    96     mask = numpy.ones(len(new_data), dtype=bool) 
     96    mask = np.ones(len(new_data), dtype=bool) 
    9797 
    9898    #TODO: make sense of the following two lines... 
    … …  
    149149 
    150150        # Get data 
    151         data = data2D.data[numpy.isfinite(data2D.data)] 
    152         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    153         qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
    154         qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
     151        data = data2D.data[np.isfinite(data2D.data)] 
     152        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     153        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     154        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    155155 
    156156        # Build array of Q intervals 
    … …  
    170170            raise RuntimeError, "_Slab._avg: unrecognized axis %s" % str(maj) 
    171171 
    172         x = numpy.zeros(nbins) 
    173         y = numpy.zeros(nbins) 
    174         err_y = numpy.zeros(nbins) 
    175         y_counts = numpy.zeros(nbins) 
     172        x = np.zeros(nbins) 
     173        y = np.zeros(nbins) 
     174        err_y = np.zeros(nbins) 
     175        y_counts = np.zeros(nbins) 
    176176 
    177177        # Average pixelsize in q space 
    … …  
    225225        y = y / y_counts 
    226226        x = x / y_counts 
    227         idx = (numpy.isfinite(y) & numpy.isfinite(x)) 
     227        idx = (np.isfinite(y) & np.isfinite(x)) 
    228228 
    229229        if not idx.any(): 
    … …  
    304304            raise RuntimeError, msg 
    305305        # Get data 
    306         data = data2D.data[numpy.isfinite(data2D.data)] 
    307         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    308         qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
    309         qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
     306        data = data2D.data[np.isfinite(data2D.data)] 
     307        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     308        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     309        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    310310 
    311311        y = 0.0 
    … …  
    414414        """ 
    415415        # Get data W/ finite values 
    416         data = data2D.data[numpy.isfinite(data2D.data)] 
    417         q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
    418         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    419         mask_data = data2D.mask[numpy.isfinite(data2D.data)] 
     416        data = data2D.data[np.isfinite(data2D.data)] 
     417        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     418        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     419        mask_data = data2D.mask[np.isfinite(data2D.data)] 
    420420 
    421421        dq_data = None 
    … …  
    430430            z_max = max(data2D.q_data) 
    431431            z_min = min(data2D.q_data) 
    432             x_max = data2D.dqx_data[numpy.where(data2D.q_data == z_max)] 
    433             x_min = data2D.dqx_data[numpy.where(data2D.q_data == z_min)] 
    434             y_max = data2D.dqy_data[numpy.where(data2D.q_data == z_max)] 
    435             y_min = data2D.dqy_data[numpy.where(data2D.q_data == z_min)] 
     432            dqx_at_z_max = data2D.dqx_data[np.argmax(data2D.q_data)] 
     433            dqx_at_z_min = data2D.dqx_data[np.argmin(data2D.q_data)] 
     434            dqy_at_z_max = data2D.dqy_data[np.argmax(data2D.q_data)] 
     435            dqy_at_z_min = data2D.dqy_data[np.argmin(data2D.q_data)] 
    436436            # Find qdx at q = 0 
    437             dq_overlap_x = (x_min * z_max - x_max * z_min) / (z_max - z_min) 
     437            dq_overlap_x = ((dqx_at_z_min * z_max - dqx_at_z_max * z_min) / 
     438                            (z_max - z_min)) 
    438439            # when extrapolation goes wrong 
    439440            if dq_overlap_x > min(data2D.dqx_data): 
    … …  
    441442            dq_overlap_x *= dq_overlap_x 
    442443            # Find qdx at q = 0 
    443             dq_overlap_y = (y_min * z_max - y_max * z_min) / (z_max - z_min) 
     444            dq_overlap_y = ((dqy_at_z_min * z_max - dqy_at_z_max * z_min) / 
     445                            (z_max - z_min)) 
    444446            # when extrapolation goes wrong 
    445447            if dq_overlap_y > min(data2D.dqy_data): 
    … …  
    448450            dq_overlap_y *= dq_overlap_y 
    449451 
    450             dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     452            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    451453            # Final protection of dq 
    452454            if dq_overlap < 0: 
    453                 dq_overlap = y_min 
    454             dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)] 
    455             dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap 
     455                dq_overlap = dqy_at_z_min 
     456            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
     457            dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap 
    456458            # def; dqx_data = dq_r dqy_data = dq_phi 
    457459            # Convert dq 2D to 1D here 
    458460            dqx = dqx_data * dqx_data 
    459461            dqy = dqy_data * dqy_data 
    460             dq_data = numpy.add(dqx, dqy) 
    461             dq_data = numpy.sqrt(dq_data) 
    462  
    463         #q_data_max = numpy.max(q_data) 
     462            dq_data = np.add(dqx, dqy) 
     463            dq_data = np.sqrt(dq_data) 
     464 
     465        #q_data_max = np.max(q_data) 
    464466        if len(data2D.q_data) is None: 
    465467            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data 
    … …  
    469471        nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width)) 
    470472 
    471         x = numpy.zeros(nbins) 
    472         y = numpy.zeros(nbins) 
    473         err_y = numpy.zeros(nbins) 
    474         err_x = numpy.zeros(nbins) 
    475         y_counts = numpy.zeros(nbins) 
     473        x = np.zeros(nbins) 
     474        y = np.zeros(nbins) 
     475        err_y = np.zeros(nbins) 
     476        err_x = np.zeros(nbins) 
     477        y_counts = np.zeros(nbins) 
    476478 
    477479        for npt in range(len(data)): 
    … …  
    527529 
    528530        err_y = err_y / y_counts 
    529         err_y[err_y == 0] = numpy.average(err_y) 
     531        err_y[err_y == 0] = np.average(err_y) 
    530532        y = y / y_counts 
    531533        x = x / y_counts 
    532         idx = (numpy.isfinite(y)) & (numpy.isfinite(x)) 
     534        idx = (np.isfinite(y)) & (np.isfinite(x)) 
    533535 
    534536        if err_x is not None: 
    … …  
    585587 
    586588        # Get data 
    587         data = data2D.data[numpy.isfinite(data2D.data)] 
    588         q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
    589         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    590         qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
    591         qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
     589        data = data2D.data[np.isfinite(data2D.data)] 
     590        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     591        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     592        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     593        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    592594 
    593595        # Set space for 1d outputs 
    594         phi_bins = numpy.zeros(self.nbins_phi) 
    595         phi_counts = numpy.zeros(self.nbins_phi) 
    596         phi_values = numpy.zeros(self.nbins_phi) 
    597         phi_err = numpy.zeros(self.nbins_phi) 
     596        phi_bins = np.zeros(self.nbins_phi) 
     597        phi_counts = np.zeros(self.nbins_phi) 
     598        phi_values = np.zeros(self.nbins_phi) 
     599        phi_err = np.zeros(self.nbins_phi) 
    598600 
    599601        # Shift to apply to calculated phi values in order 
    … …  
    636638            phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i) 
    637639 
    638         idx = (numpy.isfinite(phi_bins)) 
     640        idx = (np.isfinite(phi_bins)) 
    639641 
    640642        if not idx.any(): 
    … …  
    769771 
    770772        # Get the all data & info 
    771         data = data2D.data[numpy.isfinite(data2D.data)] 
    772         q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
    773         err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
    774         qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
    775         qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
     773        data = data2D.data[np.isfinite(data2D.data)] 
     774        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     775        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     776        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     777        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    776778        dq_data = None 
    777779 
    … …  
    785787            z_max = max(data2D.q_data) 
    786788            z_min = min(data2D.q_data) 
    787             x_max = data2D.dqx_data[numpy.where(data2D.q_data == z_max)] 
    788             x_min = data2D.dqx_data[numpy.where(data2D.q_data == z_min)] 
    789             y_max = data2D.dqy_data[numpy.where(data2D.q_data == z_max)] 
    790             y_min = data2D.dqy_data[numpy.where(data2D.q_data == z_min)] 
     789            dqx_at_z_max = data2D.dqx_data[np.argmax(data2D.q_data)] 
     790            dqx_at_z_min = data2D.dqx_data[np.argmin(data2D.q_data)] 
     791            dqy_at_z_max = data2D.dqy_data[np.argmax(data2D.q_data)] 
     792            dqy_at_z_min = data2D.dqy_data[np.argmin(data2D.q_data)] 
    791793            # Find qdx at q = 0 
    792             dq_overlap_x = (x_min * z_max - x_max * z_min) / (z_max - z_min) 
     794            dq_overlap_x = ((dqx_at_z_min * z_max - dqx_at_z_max * z_min) / 
     795                            (z_max - z_min)) 
    793796            # when extrapolation goes wrong 
    794797            if dq_overlap_x > min(data2D.dqx_data): 
    … …  
    796799            dq_overlap_x *= dq_overlap_x 
    797800            # Find qdx at q = 0 
    798             dq_overlap_y = (y_min * z_max - y_max * z_min) / (z_max - z_min) 
     801            dq_overlap_y = ((dqy_at_z_min * z_max - dqy_at_z_max * z_min) / 
     802                            (z_max - z_min)) 
    799803            # when extrapolation goes wrong 
    800804            if dq_overlap_y > min(data2D.dqy_data): 
    … …  
    803807            dq_overlap_y *= dq_overlap_y 
    804808 
    805             dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     809            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    806810            if dq_overlap < 0: 
    807                 dq_overlap = y_min 
    808             dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)] 
    809             dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap 
     811                dq_overlap = dqy_at_z_min 
     812            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
     813            dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap 
    810814            # def; dqx_data = dq_r dqy_data = dq_phi 
    811815            # Convert dq 2D to 1D here 
    812816            dqx = dqx_data * dqx_data 
    813817            dqy = dqy_data * dqy_data 
    814             dq_data = numpy.add(dqx, dqy) 
    815             dq_data = numpy.sqrt(dq_data) 
     818            dq_data = np.add(dqx, dqy) 
     819            dq_data = np.sqrt(dq_data) 
    816820 
    817821        #set space for 1d outputs 
    818         x = numpy.zeros(self.nbins) 
    819         y = numpy.zeros(self.nbins) 
    820         y_err = numpy.zeros(self.nbins) 
    821         x_err = numpy.zeros(self.nbins) 
    822         y_counts = numpy.zeros(self.nbins) 
     822        x = np.zeros(self.nbins) 
     823        y = np.zeros(self.nbins) 
     824        y_err = np.zeros(self.nbins) 
     825        x_err = np.zeros(self.nbins) 
     826        y_counts = np.zeros(self.nbins) 
    823827 
    824828        # Get the min and max into the region: 0 <= phi < 2Pi 
    … …  
    923927                #x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2) 
    924928                x[i] = x[i] / y_counts[i] 
    925         y_err[y_err == 0] = numpy.average(y_err) 
    926         idx = (numpy.isfinite(y) & numpy.isfinite(y_err)) 
     929        y_err[y_err == 0] = np.average(y_err) 
     930        idx = (np.isfinite(y) & np.isfinite(y_err)) 
    927931        if x_err is not None: 
    928932            d_x = x_err[idx] / y_counts[idx] 
    … …  
    10121016        qx_data = data2D.qx_data 
    10131017        qy_data = data2D.qy_data 
    1014         q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     1018        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    10151019 
    10161020        # check whether or not the data point is inside ROI 
    … …  
    11131117 
    11141118        # get phi from data 
    1115         phi_data = numpy.arctan2(qy_data, qx_data) 
     1119        phi_data = np.arctan2(qy_data, qx_data) 
    11161120 
    11171121        # Get the min and max into the region: -pi <= phi < Pi 

  • src/sas/sasgui/guiframe/local_perspectives/plotting/parameters_panel_slicer.py

    r3e5648b r8e15dce  
    193193                                           name="Append to file name:") 
    194194            append_tool_tip = "Files will be saved as <SlicerType><FileName>" 
    195             append_tool_tip += "<AppendToText>.xml" 
     195            append_tool_tip += "<AppendToText>.txt" 
    196196            self.append_name.SetToolTipString(append_tool_tip) 
    197197            self.append_name.SetValue(self.default_value) 
    … …  
    417417                        data_dic[item] = plot.plots[item] 
    418418 
    419         # Save files as XML 
     419        # Save files as Text 
    420420        for item, data1d in data_dic.iteritems(): 
    421421            base = '.'.join(item.split('.')[:-1]) 
    422             file_name = base + append + ".xml" 
     422            file_name = base + append + ".txt" 
    423423            save_to = evt.path + "\\" + file_name 
    424424            writer.write(save_to, data1d) 
    … …  
    439439        :param file_list: list of loaded file names to send to fit 
    440440        """ 
    441         if fit != FIT_OPTIONS[0] and file_list is not None: 
     441        if fit in FIT_OPTIONS and fit != FIT_OPTIONS[0] and \ 
     442                        file_list is not None: 
    442443            # Set perspective to fitting 
    443444            int = self.data_panel.perspective_cbox.FindString("Fitting") 
Note: See TracChangeset for help on using the changeset viewer.