Changeset fd5d6eac in sasview


Ignore:
Timestamp:
Apr 6, 2017 9:04:42 AM (7 years ago)
Author:
Ricardo Ferraz Leal <ricleal@…>
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:
a470e88
Parents:
00a6ec4
Message:

better code. Remove warnings

Files:
19 added
2 edited

Legend:

Unmodified
Added
Removed

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

    rdd11014 rfd5d6eac  
    55""" 
    66##################################################################### 
    7 #This software was developed by the University of Tennessee as part of the 
    8 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    9 #project funded by the US National Science Foundation. 
    10 #See the license text in license.txt 
    11 #copyright 2008, University of Tennessee 
     7# This software was developed by the University of Tennessee as part of the 
     8# Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     9# project funded by the US National Science Foundation. 
     10# See the license text in license.txt 
     11# copyright 2008, University of Tennessee 
    1212###################################################################### 
    1313 
    14 #TODO: copy the meta data from the 2D object to the resulting 1D object 
     14# If you want to run just a single test from this file: 
     15# PYTHONPATH=../src/ python2  -m sasdataloader.test.utest_averaging data_info_tests.test_sectorq_full 
     16# TODO: copy the meta data from the 2D object to the resulting 1D object 
    1517import math 
    16 import numpy 
     18import numpy as np 
    1719 
    1820#from data_info import plottable_2D 
    … …  
    8284    if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None: 
    8385        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)) 
     86    new_x = np.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
     87    new_y = np.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
    8688    new_y = new_y.swapaxes(0, 1) 
    8789 
    … …  
    8991    qx_data = new_x.flatten() 
    9092    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)) 
     93    q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
     94    if data2d.err_data is None or np.any(data2d.err_data <= 0): 
     95        new_err_data = np.sqrt(np.abs(new_data)) 
    9496    else: 
    9597        new_err_data = data2d.err_data.flatten() 
    96     mask = numpy.ones(len(new_data), dtype=bool) 
    97  
    98     #TODO: make sense of the following two lines... 
     98    mask = np.ones(len(new_data), dtype=bool) 
     99 
     100    # TODO: make sense of the following two lines... 
    99101    #from sas.sascalc.dataloader.data_info import Data2D 
    100102    #output = Data2D() 
    … …  
    114116    Compute average I(Q) for a region of interest 
    115117    """ 
     118 
    116119    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, 
    117120                 y_max=0.0, bin_width=0.001): 
    … …  
    149152 
    150153        # 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)] 
     154        data = data2D.data[np.isfinite(data2D.data)] 
     155        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     156        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     157        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    155158 
    156159        # Build array of Q intervals 
    … …  
    170173            raise RuntimeError, "_Slab._avg: unrecognized axis %s" % str(maj) 
    171174 
    172         x = numpy.zeros(nbins) 
    173         y = numpy.zeros(nbins) 
    174         err_y = numpy.zeros(nbins) 
    175         y_counts = numpy.zeros(nbins) 
     175        x = np.zeros(nbins) 
     176        y = np.zeros(nbins) 
     177        err_y = np.zeros(nbins) 
     178        y_counts = np.zeros(nbins) 
    176179 
    177180        # Average pixelsize in q space 
    … …  
    205208                continue 
    206209 
    207             #TODO: find better definition of x[i_q] based on q_data 
     210            # TODO: find better definition of x[i_q] based on q_data 
    208211            # min_value + (i_q + 1) * self.bin_width / 2.0 
    209212            x[i_q] += frac * q_value 
    210213            y[i_q] += frac * data[npts] 
    211214 
    212             if err_data == None or err_data[npts] == 0.0: 
     215            if err_data is None or err_data[npts] == 0.0: 
    213216                if data[npts] < 0: 
    214217                    data[npts] = -data[npts] 
    … …  
    225228        y = y / y_counts 
    226229        x = x / y_counts 
    227         idx = (numpy.isfinite(y) & numpy.isfinite(x)) 
     230        idx = (np.isfinite(y) & np.isfinite(x)) 
    228231 
    229232        if not idx.any(): 
    … …  
    237240    Compute average I(Qy) for a region of interest 
    238241    """ 
     242 
    239243    def __call__(self, data2D): 
    240244        """ 
    … …  
    251255    Compute average I(Qx) for a region of interest 
    252256    """ 
     257 
    253258    def __call__(self, data2D): 
    254259        """ 
    … …  
    264269    Perform the sum of counts in a 2D region of interest. 
    265270    """ 
     271 
    266272    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0): 
    267273        # Minimum Qx value [A-1] 
    … …  
    304310            raise RuntimeError, msg 
    305311        # 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)] 
     312        data = data2D.data[np.isfinite(data2D.data)] 
     313        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     314        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     315        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    310316 
    311317        y = 0.0 
    … …  
    328334            if self.y_min <= qy and self.y_max > qy: 
    329335                frac_y = 1 
    330             #Find the fraction along each directions 
     336            # Find the fraction along each directions 
    331337            frac = frac_x * frac_y 
    332338            if frac == 0: 
    333339                continue 
    334340            y += frac * data[npts] 
    335             if err_data == None or err_data[npts] == 0.0: 
     341            if err_data is None or err_data[npts] == 0.0: 
    336342                if data[npts] < 0: 
    337343                    data[npts] = -data[npts] 
    … …  
    347353    Perform the average of counts in a 2D region of interest. 
    348354    """ 
     355 
    349356    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0): 
    350357        super(Boxavg, self).__init__(x_min=x_min, x_max=x_max, 
    … …  
    398405    as a function of Q 
    399406    """ 
     407 
    400408    def __init__(self, r_min=0.0, r_max=0.0, bin_width=0.0005): 
    401409        # Minimum radius included in the average [A-1] 
    … …  
    414422        """ 
    415423        # 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)] 
     424        data = data2D.data[np.isfinite(data2D.data)] 
     425        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     426        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     427        mask_data = data2D.mask[np.isfinite(data2D.data)] 
    420428 
    421429        dq_data = None 
    … …  
    448456            dq_overlap_y *= dq_overlap_y 
    449457 
    450             dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     458            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    451459            # Final protection of dq 
    452460            if dq_overlap < 0: 
    453461                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 
     462            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
     463            dqy_data = data2D.dqy_data[np.isfinite( 
     464                data2D.data)] - dq_overlap 
    456465            # def; dqx_data = dq_r dqy_data = dq_phi 
    457466            # Convert dq 2D to 1D here 
    458467            dqx = dqx_data * dqx_data 
    459468            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) 
     469            dq_data = np.add(dqx, dqy) 
     470            dq_data = np.sqrt(dq_data) 
     471 
     472        #q_data_max = np.max(q_data) 
    464473        if len(data2D.q_data) == None: 
    465474            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data 
    … …  
    469478        nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width)) 
    470479 
    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) 
     480        x = np.zeros(nbins) 
     481        y = np.zeros(nbins) 
     482        err_y = np.zeros(nbins) 
     483        err_x = np.zeros(nbins) 
     484        y_counts = np.zeros(nbins) 
    476485 
    477486        for npt in range(len(data)): 
    … …  
    486495            data_n = data[npt] 
    487496 
    488             ## No need to calculate the frac when all data are within range 
     497            # No need to calculate the frac when all data are within range 
    489498            if self.r_min >= self.r_max: 
    490499                raise ValueError, "Limit Error: min > max" 
    … …  
    502511            # Take dqs from data to get the q_average 
    503512            x[i_q] += frac * q_value 
    504             if err_data == None or err_data[npt] == 0.0: 
     513            if err_data is None or err_data[npt] == 0.0: 
    505514                if data_n < 0: 
    506515                    data_n = -data_n 
    … …  
    523532                err_y[n] = -err_y[n] 
    524533            err_y[n] = math.sqrt(err_y[n]) 
    525             #if err_x != None: 
     534            # if err_x != None: 
    526535            #    err_x[n] = math.sqrt(err_x[n]) 
    527536 
    528537        err_y = err_y / y_counts 
    529         err_y[err_y == 0] = numpy.average(err_y) 
     538        err_y[err_y == 0] = np.average(err_y) 
    530539        y = y / y_counts 
    531540        x = x / y_counts 
    532         idx = (numpy.isfinite(y)) & (numpy.isfinite(x)) 
     541        idx = (np.isfinite(y)) & (np.isfinite(x)) 
    533542 
    534543        if err_x != None: 
    … …  
    556565    in anti-clockwise starting from the x- axis on the left-hand side 
    557566    """ 
    558     #Todo: remove center. 
     567    # Todo: remove center. 
     568 
    559569    def __init__(self, r_min=0, r_max=0, center_x=0, center_y=0, nbins=36): 
    560570        # Minimum radius 
    … …  
    569579        self.nbins_phi = nbins 
    570580 
    571  
    572581    def __call__(self, data2D): 
    573582        """ 
    … …  
    585594 
    586595        # 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)] 
     596        data = data2D.data[np.isfinite(data2D.data)] 
     597        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     598        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     599        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     600        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    592601 
    593602        # 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) 
     603        phi_bins = np.zeros(self.nbins_phi) 
     604        phi_counts = np.zeros(self.nbins_phi) 
     605        phi_values = np.zeros(self.nbins_phi) 
     606        phi_err = np.zeros(self.nbins_phi) 
    598607 
    599608        # Shift to apply to calculated phi values in order 
    … …  
    615624                continue 
    616625            # binning 
    617             i_phi = int(math.floor((self.nbins_phi) * \ 
     626            i_phi = int(math.floor((self.nbins_phi) * 
    618627                                   (phi_value + phi_shift) / (2 * Pi))) 
    619628 
    … …  
    623632            phi_bins[i_phi] += frac * data[npt] 
    624633 
    625             if err_data == None or err_data[npt] == 0.0: 
     634            if err_data is None or err_data[npt] == 0.0: 
    626635                if data_n < 0: 
    627636                    data_n = -data_n 
    … …  
    636645            phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i) 
    637646 
    638         idx = (numpy.isfinite(phi_bins)) 
     647        idx = (np.isfinite(phi_bins)) 
    639648 
    640649        if not idx.any(): 
    641650            msg = "Average Error: No points inside ROI to average..." 
    642651            raise ValueError, msg 
    643         #elif len(phi_bins[idx])!= self.nbins_phi: 
     652        # elif len(phi_bins[idx])!= self.nbins_phi: 
    644653        #    print "resulted",self.nbins_phi- len(phi_bins[idx]) 
    645654        #,"empty bin(s) due to tight binning..." 
    … …  
    748757    starting from the x- axis on the left-hand side 
    749758    """ 
     759 
    750760    def __init__(self, r_min, r_max, phi_min=0, phi_max=2 * math.pi, nbins=20): 
    751761        self.r_min = r_min 
    … …  
    769779 
    770780        # 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)] 
     781        data = data2D.data[np.isfinite(data2D.data)] 
     782        q_data = data2D.q_data[np.isfinite(data2D.data)] 
     783        err_data = data2D.err_data[np.isfinite(data2D.data)] 
     784        qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
     785        qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
    776786        dq_data = None 
    777787 
    … …  
    803813            dq_overlap_y *= dq_overlap_y 
    804814 
    805             dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     815            dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    806816            if dq_overlap < 0: 
    807817                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 
     818            dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
     819            dqy_data = data2D.dqy_data[np.isfinite( 
     820                data2D.data)] - dq_overlap 
    810821            # def; dqx_data = dq_r dqy_data = dq_phi 
    811822            # Convert dq 2D to 1D here 
    812823            dqx = dqx_data * dqx_data 
    813824            dqy = dqy_data * dqy_data 
    814             dq_data = numpy.add(dqx, dqy) 
    815             dq_data = numpy.sqrt(dq_data) 
    816  
    817         #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) 
     825            dq_data = np.add(dqx, dqy) 
     826            dq_data = np.sqrt(dq_data) 
     827 
     828        # set space for 1d outputs 
     829        x = np.zeros(self.nbins) 
     830        y = np.zeros(self.nbins) 
     831        y_err = np.zeros(self.nbins) 
     832        x_err = np.zeros(self.nbins) 
     833        y_counts = np.zeros(self.nbins) 
    823834 
    824835        # Get the min and max into the region: 0 <= phi < 2Pi 
    … …  
    839850            phi_value = math.atan2(qy_data[n], qx_data[n]) + Pi 
    840851 
    841             ## No need to calculate the frac when all data are within range 
     852            # No need to calculate the frac when all data are within range 
    842853            if self.r_min <= q_value and q_value <= self.r_max: 
    843854                frac = 1 
    844855            if frac == 0: 
    845856                continue 
    846             #In case of two ROIs (symmetric major and minor regions)(for 'q2') 
     857            # In case of two ROIs (symmetric major and minor regions)(for 'q2') 
    847858            if run.lower() == 'q2': 
    848                 ## For minor sector wing 
     859                # For minor sector wing 
    849860                # Calculate the minor wing phis 
    850861                phi_min_minor = flip_phi(phi_min - Pi) 
    … …  
    852863                # Check if phis of the minor ring is within 0 to 2pi 
    853864                if phi_min_minor > phi_max_minor: 
    854                     is_in = (phi_value > phi_min_minor or \ 
    855                               phi_value < phi_max_minor) 
     865                    is_in = (phi_value > phi_min_minor or 
     866                             phi_value < phi_max_minor) 
    856867                else: 
    857                     is_in = (phi_value > phi_min_minor and \ 
    858                               phi_value < phi_max_minor) 
    859  
    860             #For all cases(i.e.,for 'q', 'q2', and 'phi') 
    861             #Find pixels within ROI 
     868                    is_in = (phi_value > phi_min_minor and 
     869                             phi_value < phi_max_minor) 
     870 
     871            # For all cases(i.e.,for 'q', 'q2', and 'phi') 
     872            # Find pixels within ROI 
    862873            if phi_min > phi_max: 
    863                 is_in = is_in or (phi_value > phi_min or \ 
    864                                    phi_value < phi_max) 
     874                is_in = is_in or (phi_value > phi_min or 
     875                                  phi_value < phi_max) 
    865876            else: 
    866                 is_in = is_in or (phi_value >= phi_min  and \ 
    867                                     phi_value < phi_max) 
     877                is_in = is_in or (phi_value >= phi_min and 
     878                                  phi_value < phi_max) 
    868879 
    869880            if not is_in: 
    … …  
    885896                i_bin = self.nbins - 1 
    886897 
    887             ## Get the total y 
     898            # Get the total y 
    888899            y[i_bin] += frac * data_n 
    889900            x[i_bin] += frac * q_value 
    … …  
    923934                #x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2) 
    924935                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)) 
     936        y_err[y_err == 0] = np.average(y_err) 
     937        idx = (np.isfinite(y) & np.isfinite(y_err)) 
    927938        if x_err != None: 
    928939            d_x = x_err[idx] / y_counts[idx] 
    … …  
    932943            msg = "Average Error: No points inside sector of ROI to average..." 
    933944            raise ValueError, msg 
    934         #elif len(y[idx])!= self.nbins: 
     945        # elif len(y[idx])!= self.nbins: 
    935946        #    print "resulted",self.nbins- len(y[idx]), 
    936947        #"empty bin(s) due to tight binning..." 
    … …  
    946957    The number of bin in phi also has to be defined. 
    947958    """ 
     959 
    948960    def __call__(self, data2D): 
    949961        """ 
    … …  
    965977    The number of bin in Q also has to be defined. 
    966978    """ 
     979 
    967980    def __call__(self, data2D): 
    968981        """ 
    … …  
    9871000    in anti-clockwise starting from the x- axis on the left-hand side 
    9881001    """ 
     1002 
    9891003    def __init__(self, r_min=0, r_max=0, center_x=0, center_y=0): 
    9901004        # Minimum radius 
    … …  
    10121026        qx_data = data2D.qx_data 
    10131027        qy_data = data2D.qy_data 
    1014         q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     1028        q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    10151029 
    10161030        # check whether or not the data point is inside ROI 
    … …  
    10231037    Find a rectangular 2D region of interest. 
    10241038    """ 
     1039 
    10251040    def __init__(self, x_min=0.0, x_max=0.0, y_min=0.0, y_max=0.0): 
    10261041        # Minimum Qx value [A-1] 
    … …  
    10771092    and (phi_max-phi_min) should not be larger than pi 
    10781093    """ 
     1094 
    10791095    def __init__(self, phi_min=0, phi_max=math.pi): 
    10801096        self.phi_min = phi_min 
    … …  
    11131129 
    11141130        # get phi from data 
    1115         phi_data = numpy.arctan2(qy_data, qx_data) 
     1131        phi_data = np.arctan2(qy_data, qx_data) 
    11161132 
    11171133        # Get the min and max into the region: -pi <= phi < Pi 
    … …  
    11201136        # check for major sector 
    11211137        if phi_min_major > phi_max_major: 
    1122             out_major = (phi_min_major <= phi_data) + (phi_max_major > phi_data) 
     1138            out_major = (phi_min_major <= phi_data) + \ 
     1139                (phi_max_major > phi_data) 
    11231140        else: 
    1124             out_major = (phi_min_major <= phi_data) & (phi_max_major > phi_data) 
     1141            out_major = (phi_min_major <= phi_data) & ( 
     1142                phi_max_major > phi_data) 
    11251143 
    11261144        # minor sector 
    … …  
    11321150        if phi_min_minor > phi_max_minor: 
    11331151            out_minor = (phi_min_minor <= phi_data) + \ 
    1134                             (phi_max_minor >= phi_data) 
     1152                (phi_max_minor >= phi_data) 
    11351153        else: 
    11361154            out_minor = (phi_min_minor <= phi_data) & \ 
    1137                             (phi_max_minor >= phi_data) 
     1155                (phi_max_minor >= phi_data) 
    11381156        out = out_major + out_minor 
    11391157 

  • test/sasguiframe/test/utest_manipulations.py

    r9a5097c rfd5d6eac  
    22    Unit tests for data manipulations 
    33""" 
    4 #TODO: what happens if you add a Data1D to a Data2D? 
    5  
     4# TODO: what happens if you add a Data1D to a Data2D? 
     5 
     6import math 
     7import os.path 
    68import unittest 
    7 import math 
     9 
    810import numpy as np 
    9 from sas.sascalc.dataloader.loader import  Loader 
    10 from sas.sasgui.guiframe.dataFitting import Data1D, Data2D 
     11 
     12from sas.sascalc.dataloader.loader import Loader 
    1113from sas.sasgui.guiframe.dataFitting import Data1D as Theory1D 
    12   
    13 import os.path 
     14from sas.sasgui.guiframe.dataFitting import Data2D 
     15 
    1416 
    1517class data_info_tests(unittest.TestCase): 
    16      
     18 
    1719    def setUp(self): 
    1820        data = Loader().load("cansas1d.xml") 
    1921        self.data = data[0] 
    20          
     22 
    2123    def test_clone1D(self): 
    2224        """ 
    … …  
    2426        """ 
    2527        clone = self.data.clone_without_data() 
    26          
     28 
    2729        for i in range(len(self.data.detector)): 
    28             self.assertEqual(self.data.detector[i].distance, clone.detector[i].distance) 
    29              
     30            self.assertEqual( 
     31                self.data.detector[i].distance, clone.detector[i].distance) 
     32 
     33 
    3034class theory1d_tests(unittest.TestCase): 
    31      
     35 
    3236    def setUp(self): 
    3337        data = Loader().load("cansas1d.xml") 
    3438        self.data = data[0] 
    35          
     39 
    3640    def test_clone_theory1D(self): 
    3741        """ 
    … …  
    4246        theory.copy_from_datainfo(data1d=self.data) 
    4347        for i in range(len(self.data.detector)): 
    44             self.assertEqual(self.data.detector[i].distance, theory.detector[i].distance) 
    45              
     48            self.assertEqual( 
     49                self.data.detector[i].distance, theory.detector[i].distance) 
     50 
    4651        for i in range(len(self.data.x)): 
    4752            self.assertEqual(self.data.x[i], theory.x[i]) 
    … …  
    4954            self.assertEqual(self.data.dy[i], theory.dy[i]) 
    5055 
     56 
    5157class manip_tests(unittest.TestCase): 
    52      
     58 
    5359    def setUp(self): 
    5460        # Create two data sets to play with 
    5561        x_0 = np.ones(5) 
    5662        for i in range(5): 
    57             x_0[i] = x_0[i]*(i+1.0) 
    58              
    59         y_0 = 2.0*np.ones(5) 
    60         dy_0 = 0.5*np.ones(5) 
     63            x_0[i] = x_0[i] * (i + 1.0) 
     64 
     65        y_0 = 2.0 * np.ones(5) 
     66        dy_0 = 0.5 * np.ones(5) 
    6167        self.data = Data1D(x_0, y_0, dy=dy_0) 
    62          
     68 
    6369        x = self.data.x 
    6470        y = np.ones(5) 
    6571        dy = np.ones(5) 
    6672        self.data2 = Data1D(x, y, dy=dy) 
    67          
    68          
     73 
    6974    def test_load(self): 
    7075        """ 
    … …  
    7378        # There should be 5 entries in the file 
    7479        self.assertEqual(len(self.data.x), 5) 
    75          
     80 
    7681        for i in range(5): 
    7782            # The x values should be from 1 to 5 
    78             self.assertEqual(self.data.x[i], float(i+1)) 
    79          
     83            self.assertEqual(self.data.x[i], float(i + 1)) 
     84 
    8085            # All y-error values should be 0.5 
    81             self.assertEqual(self.data.dy[i], 0.5)     
    82              
     86            self.assertEqual(self.data.dy[i], 0.5) 
     87 
    8388            # All y values should be 2.0 
    84             self.assertEqual(self.data.y[i], 2.0)     
    85          
     89            self.assertEqual(self.data.y[i], 2.0) 
     90 
    8691    def test_add(self): 
    87         result = self.data2+self.data 
     92        result = self.data2 + self.data 
    8893        for i in range(5): 
    8994            self.assertEqual(result.y[i], 3.0) 
    90             self.assertEqual(result.dy[i], math.sqrt(0.5**2+1.0)) 
    91          
     95            self.assertEqual(result.dy[i], math.sqrt(0.5**2 + 1.0)) 
     96 
    9297    def test_sub(self): 
    93         result = self.data2-self.data 
     98        result = self.data2 - self.data 
    9499        for i in range(5): 
    95100            self.assertEqual(result.y[i], -1.0) 
    96             self.assertEqual(result.dy[i], math.sqrt(0.5**2+1.0)) 
    97          
     101            self.assertEqual(result.dy[i], math.sqrt(0.5**2 + 1.0)) 
     102 
    98103    def test_mul(self): 
    99         result = self.data2*self.data 
     104        result = self.data2 * self.data 
    100105        for i in range(5): 
    101106            self.assertEqual(result.y[i], 2.0) 
    102             self.assertEqual(result.dy[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2)) 
    103          
     107            self.assertEqual(result.dy[i], math.sqrt( 
     108                (0.5 * 1.0)**2 + (1.0 * 2.0)**2)) 
     109 
    104110    def test_div(self): 
    105         result = self.data2/self.data 
     111        result = self.data2 / self.data 
    106112        for i in range(5): 
    107113            self.assertEqual(result.y[i], 0.5) 
    108             self.assertEqual(result.dy[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2)) 
    109          
     114            self.assertEqual(result.dy[i], math.sqrt( 
     115                (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2)) 
     116 
    110117    def test_radd(self): 
    111         result = self.data+3.0 
     118        result = self.data + 3.0 
    112119        for i in range(5): 
    113120            self.assertEqual(result.y[i], 5.0) 
    114121            self.assertEqual(result.dy[i], 0.5) 
    115              
    116         result = 3.0+self.data 
     122 
     123        result = 3.0 + self.data 
    117124        for i in range(5): 
    118125            self.assertEqual(result.y[i], 5.0) 
    119126            self.assertEqual(result.dy[i], 0.5) 
    120              
     127 
    121128    def test_rsub(self): 
    122         result = self.data-3.0 
     129        result = self.data - 3.0 
    123130        for i in range(5): 
    124131            self.assertEqual(result.y[i], -1.0) 
    125132            self.assertEqual(result.dy[i], 0.5) 
    126              
    127         result = 3.0-self.data 
     133 
     134        result = 3.0 - self.data 
    128135        for i in range(5): 
    129136            self.assertEqual(result.y[i], 1.0) 
    130137            self.assertEqual(result.dy[i], 0.5) 
    131              
     138 
    132139    def test_rmul(self): 
    133         result = self.data*3.0 
     140        result = self.data * 3.0 
    134141        for i in range(5): 
    135142            self.assertEqual(result.y[i], 6.0) 
    136143            self.assertEqual(result.dy[i], 1.5) 
    137              
    138         result = 3.0*self.data 
     144 
     145        result = 3.0 * self.data 
    139146        for i in range(5): 
    140147            self.assertEqual(result.y[i], 6.0) 
    141148            self.assertEqual(result.dy[i], 1.5) 
    142              
     149 
    143150    def test_rdiv(self): 
    144         result = self.data/4.0 
     151        result = self.data / 4.0 
    145152        for i in range(5): 
    146153            self.assertEqual(result.y[i], 0.5) 
    147154            self.assertEqual(result.dy[i], 0.125) 
    148              
    149         result = 6.0/self.data 
     155 
     156        result = 6.0 / self.data 
    150157        for i in range(5): 
    151158            self.assertEqual(result.y[i], 3.0) 
    152             self.assertEqual(result.dy[i], 6.0*0.5/4.0) 
    153              
     159            self.assertEqual(result.dy[i], 6.0 * 0.5 / 4.0) 
     160 
     161 
    154162class manip_2D(unittest.TestCase): 
    155      
     163 
    156164    def setUp(self): 
    157165        # Create two data sets to play with 
    158         x_0 = 2.0*np.ones(25) 
    159         dx_0 = 0.5*np.ones(25) 
     166        x_0 = 2.0 * np.ones(25) 
     167        dx_0 = 0.5 * np.ones(25) 
    160168        qx_0 = np.arange(25) 
    161169        qy_0 = np.arange(25) 
    162170        mask_0 = np.zeros(25) 
    163         dqx_0 = np.arange(25)/100 
    164         dqy_0 = np.arange(25)/100 
     171        dqx_0 = np.arange(25) / 100 
     172        dqy_0 = np.arange(25) / 100 
    165173        q_0 = np.sqrt(qx_0 * qx_0 + qy_0 * qy_0) 
    166         self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0,  
    167                            qy_data=qy_0, q_data=q_0, mask=mask_0,  
     174        self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0, 
     175                           qy_data=qy_0, q_data=q_0, mask=mask_0, 
    168176                           dqx_data=dqx_0, dqy_data=dqy_0) 
    169          
     177 
    170178        y = np.ones(25) 
    171179        dy = np.ones(25) 
    … …  
    174182        mask = np.zeros(25) 
    175183        q = np.sqrt(qx * qx + qy * qy) 
    176         self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy,  
     184        self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy, 
    177185                            q_data=q, mask=mask) 
    178          
    179          
     186 
    180187    def test_load(self): 
    181188        """ 
    … …  
    184191        # There should be 5 entries in the file 
    185192        self.assertEqual(np.size(self.data.data), 25) 
    186          
     193 
    187194        for i in range(25): 
    188195            # All y-error values should be 0.5 
    189             self.assertEqual(self.data.err_data[i], 0.5)     
    190              
     196            self.assertEqual(self.data.err_data[i], 0.5) 
     197 
    191198            # All y values should be 2.0 
    192             self.assertEqual(self.data.data[i], 2.0)     
    193          
     199            self.assertEqual(self.data.data[i], 2.0) 
     200 
    194201    def test_add(self): 
    195         result = self.data2+self.data 
     202        result = self.data2 + self.data 
    196203        for i in range(25): 
    197204            self.assertEqual(result.data[i], 3.0) 
    198             self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0)) 
    199          
     205            self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0)) 
     206 
    200207    def test_sub(self): 
    201         result = self.data2-self.data 
    202         for i in range(25): 
    203                 self.assertEqual(result.data[i], -1.0) 
    204                 self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0)) 
    205          
     208        result = self.data2 - self.data 
     209        for i in range(25): 
     210            self.assertEqual(result.data[i], -1.0) 
     211            self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0)) 
     212 
    206213    def test_mul(self): 
    207         result = self.data2*self.data 
     214        result = self.data2 * self.data 
    208215        for i in range(25): 
    209216            self.assertEqual(result.data[i], 2.0) 
    210             self.assertEqual(result.err_data[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2)) 
    211          
     217            self.assertEqual(result.err_data[i], math.sqrt( 
     218                (0.5 * 1.0)**2 + (1.0 * 2.0)**2)) 
     219 
    212220    def test_div(self): 
    213         result = self.data2/self.data 
     221        result = self.data2 / self.data 
    214222        for i in range(25): 
    215223            self.assertEqual(result.data[i], 0.5) 
    216             self.assertEqual(result.err_data[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2)) 
    217          
     224            self.assertEqual(result.err_data[i], math.sqrt( 
     225                (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2)) 
     226 
    218227    def test_radd(self): 
    219         result = self.data+3.0 
     228        result = self.data + 3.0 
    220229        for i in range(25): 
    221230            self.assertEqual(result.data[i], 5.0) 
    222231            self.assertEqual(result.err_data[i], 0.5) 
    223     
    224         result = 3.0+self.data 
     232 
     233        result = 3.0 + self.data 
    225234        for i in range(25): 
    226235            self.assertEqual(result.data[i], 5.0) 
    227236            self.assertEqual(result.err_data[i], 0.5) 
    228              
     237 
    229238    def test_rsub(self): 
    230         result = self.data-3.0 
     239        result = self.data - 3.0 
    231240        for i in range(25): 
    232241            self.assertEqual(result.data[i], -1.0) 
    233242            self.assertEqual(result.err_data[i], 0.5) 
    234      
    235         result = 3.0-self.data 
     243 
     244        result = 3.0 - self.data 
    236245        for i in range(25): 
    237246            self.assertEqual(result.data[i], 1.0) 
    238247            self.assertEqual(result.err_data[i], 0.5) 
    239              
     248 
    240249    def test_rmul(self): 
    241         result = self.data*3.0 
     250        result = self.data * 3.0 
    242251        for i in range(25): 
    243252            self.assertEqual(result.data[i], 6.0) 
    244253            self.assertEqual(result.err_data[i], 1.5) 
    245   
    246         result = 3.0*self.data 
     254 
     255        result = 3.0 * self.data 
    247256        for i in range(25): 
    248257            self.assertEqual(result.data[i], 6.0) 
    249258            self.assertEqual(result.err_data[i], 1.5) 
    250              
     259 
    251260    def test_rdiv(self): 
    252         result = self.data/4.0 
     261        result = self.data / 4.0 
    253262        for i in range(25): 
    254263            self.assertEqual(result.data[i], 0.5) 
    255264            self.assertEqual(result.err_data[i], 0.125) 
    256265 
    257         result = 6.0/self.data 
     266        result = 6.0 / self.data 
    258267        for i in range(25): 
    259268            self.assertEqual(result.data[i], 3.0) 
    260             self.assertEqual(result.err_data[i], 6.0*0.5/4.0) 
    261      
     269            self.assertEqual(result.err_data[i], 6.0 * 0.5 / 4.0) 
     270 
     271 
    262272class extra_manip_2D(unittest.TestCase): 
    263      
     273 
    264274    def setUp(self): 
    265275        # Create two data sets to play with 
    266         x_0 = 2.0*np.ones(25) 
    267         dx_0 = 0.5*np.ones(25) 
     276        x_0 = 2.0 * np.ones(25) 
     277        dx_0 = 0.5 * np.ones(25) 
    268278        qx_0 = np.arange(25) 
    269279        qy_0 = np.arange(25) 
    270280        mask_0 = np.zeros(25) 
    271         dqx_0 = np.arange(25)/100 
    272         dqy_0 = np.arange(25)/100 
     281        dqx_0 = np.arange(25) / 100 
     282        dqy_0 = np.arange(25) / 100 
    273283        q_0 = np.sqrt(qx_0 * qx_0 + qy_0 * qy_0) 
    274         self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0,  
    275                            qy_data=qy_0, q_data=q_0, mask=mask_0,  
     284        self.data = Data2D(image=x_0, err_image=dx_0, qx_data=qx_0, 
     285                           qy_data=qy_0, q_data=q_0, mask=mask_0, 
    276286                           dqx_data=dqx_0, dqy_data=dqy_0) 
    277          
     287 
    278288        y = np.ones(25) 
    279289        dy = np.ones(25) 
    … …  
    282292        mask = np.zeros(25) 
    283293        q = np.sqrt(qx * qx + qy * qy) 
    284         self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy,  
     294        self.data2 = Data2D(image=y, err_image=dy, qx_data=qx, qy_data=qy, 
    285295                            q_data=q, mask=mask) 
    286          
    287          
     296 
    288297    def test_load(self): 
    289298        """ 
    … …  
    292301        # There should be 5 entries in the file 
    293302        self.assertEqual(np.size(self.data.data), 25) 
    294          
     303 
    295304        for i in range(25): 
    296305            # All y-error values should be 0.5 
    297             self.assertEqual(self.data.err_data[i], 0.5)     
    298              
     306            self.assertEqual(self.data.err_data[i], 0.5) 
     307 
    299308            # All y values should be 2.0 
    300             self.assertEqual(self.data.data[i], 2.0)     
    301          
     309            self.assertEqual(self.data.data[i], 2.0) 
     310 
    302311    def test_add(self): 
    303         result = self.data2+self.data 
     312        result = self.data2 + self.data 
    304313        for i in range(25): 
    305314            self.assertEqual(result.data[i], 3.0) 
    306             self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0)) 
    307          
     315            self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0)) 
     316 
    308317    def test_sub(self): 
    309         result = self.data2-self.data 
    310         for i in range(25): 
    311                 self.assertEqual(result.data[i], -1.0) 
    312                 self.assertEqual(result.err_data[i], math.sqrt(0.5**2+1.0)) 
    313          
     318        result = self.data2 - self.data 
     319        for i in range(25): 
     320            self.assertEqual(result.data[i], -1.0) 
     321            self.assertEqual(result.err_data[i], math.sqrt(0.5**2 + 1.0)) 
     322 
    314323    def test_mul(self): 
    315         result = self.data2*self.data 
     324        result = self.data2 * self.data 
    316325        for i in range(25): 
    317326            self.assertEqual(result.data[i], 2.0) 
    318             self.assertEqual(result.err_data[i], math.sqrt((0.5*1.0)**2+(1.0*2.0)**2)) 
    319          
     327            self.assertEqual(result.err_data[i], math.sqrt( 
     328                (0.5 * 1.0)**2 + (1.0 * 2.0)**2)) 
     329 
    320330    def test_div(self): 
    321         result = self.data2/self.data 
     331        result = self.data2 / self.data 
    322332        for i in range(25): 
    323333            self.assertEqual(result.data[i], 0.5) 
    324             self.assertEqual(result.err_data[i], math.sqrt((1.0/2.0)**2+(0.5*1.0/4.0)**2)) 
    325          
     334            self.assertEqual(result.err_data[i], math.sqrt( 
     335                (1.0 / 2.0)**2 + (0.5 * 1.0 / 4.0)**2)) 
     336 
    326337    def test_radd(self): 
    327         result = self.data+3.0 
     338        result = self.data + 3.0 
    328339        for i in range(25): 
    329340            self.assertEqual(result.data[i], 5.0) 
    330341            self.assertEqual(result.err_data[i], 0.5) 
    331     
    332         result = 3.0+self.data 
     342 
     343        result = 3.0 + self.data 
    333344        for i in range(25): 
    334345            self.assertEqual(result.data[i], 5.0) 
    335346            self.assertEqual(result.err_data[i], 0.5) 
    336              
     347 
    337348    def test_rsub(self): 
    338         result = self.data-3.0 
     349        result = self.data - 3.0 
    339350        for i in range(25): 
    340351            self.assertEqual(result.data[i], -1.0) 
    341352            self.assertEqual(result.err_data[i], 0.5) 
    342      
    343         result = 3.0-self.data 
     353 
     354        result = 3.0 - self.data 
    344355        for i in range(25): 
    345356            self.assertEqual(result.data[i], 1.0) 
    346357            self.assertEqual(result.err_data[i], 0.5) 
    347              
     358 
    348359    def test_rmul(self): 
    349         result = self.data*3.0 
     360        result = self.data * 3.0 
    350361        for i in range(25): 
    351362            self.assertEqual(result.data[i], 6.0) 
    352363            self.assertEqual(result.err_data[i], 1.5) 
    353   
    354         result = 3.0*self.data 
     364 
     365        result = 3.0 * self.data 
    355366        for i in range(25): 
    356367            self.assertEqual(result.data[i], 6.0) 
    357368            self.assertEqual(result.err_data[i], 1.5) 
    358              
     369 
    359370    def test_rdiv(self): 
    360         result = self.data/4.0 
     371        result = self.data / 4.0 
    361372        for i in range(25): 
    362373            self.assertEqual(result.data[i], 0.5) 
    363374            self.assertEqual(result.err_data[i], 0.125) 
    364375 
    365         result = 6.0/self.data 
     376        result = 6.0 / self.data 
    366377        for i in range(25): 
    367378            self.assertEqual(result.data[i], 3.0) 
    368             self.assertEqual(result.err_data[i], 6.0*0.5/4.0) 
     379            self.assertEqual(result.err_data[i], 6.0 * 0.5 / 4.0) 
     380 
    369381 
    370382if __name__ == '__main__': 
    371383    unittest.main() 
    372     
Note: See TracChangeset for help on using the changeset viewer.