Changeset fadb757 in sasview for src/sas/sascalc/dataloader


Ignore:
Timestamp:
May 2, 2017 5:36:21 AM (8 years ago)
Author:
GitHub <noreply@…>
Parents:
658dd57 (diff), 8390cf6 (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:
Adam Washington <rprospero@…> (05/02/17 05:36:21)
git-committer:
GitHub <noreply@…> (05/02/17 05:36:21)
Message:

Merge 8390cf6d9c8beeeaa632fa76e26b0679e3907444 into 658dd573a2872185ffe7439d96b51458fb88a94d

Location:
src/sas/sascalc/dataloader
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

    r9a5097c rcb9feea8  
    11""" 
    22    SESANS reader (based on ASCII reader) 
    3      
     3 
    44    Reader for .ses or .sesans file format 
    5      
    6     Jurrian Bakker  
     5 
     6    Jurrian Bakker 
    77""" 
    88import numpy as np 
    … …  
    1818_ZERO = 1e-16 
    1919 
     20 
    2021class Reader: 
    2122    """ 
    2223    Class to load sesans files (6 columns). 
    2324    """ 
    24     ## File type 
     25    # File type 
    2526    type_name = "SESANS" 
    26      
    27     ## Wildcards 
     27 
     28    # Wildcards 
    2829    type = ["SESANS files (*.ses)|*.ses", 
    2930            "SESANS files (*..sesans)|*.sesans"] 
    30     ## List of allowed extensions 
     31    # List of allowed extensions 
    3132    ext = ['.ses', '.SES', '.sesans', '.SESANS'] 
    32      
    33     ## Flag to bypass extension check 
     33 
     34    # Flag to bypass extension check 
    3435    allow_all = True 
    35      
     36 
    3637    def read(self, path): 
    37          
    38 #        print "reader triggered" 
    39          
    4038        """ 
    4139        Load data file 
    42          
     40 
    4341        :param path: file path 
    44          
     42 
    4543        :return: SESANSData1D object, or None 
    46          
     44 
    4745        :raise RuntimeError: when the file can't be opened 
    4846        :raise ValueError: when the length of the data vectors are inconsistent 
    … …  
    5149            basename = os.path.basename(path) 
    5250            _, extension = os.path.splitext(basename) 
    53             if self.allow_all or extension.lower() in self.ext: 
    54                 try: 
    55                     # Read in binary mode since GRASP frequently has no-ascii 
    56                     # characters that brakes the open operation 
    57                     input_f = open(path,'rb') 
    58                 except: 
    59                     raise  RuntimeError, "sesans_reader: cannot open %s" % path 
    60                 buff = input_f.read() 
    61                 lines = buff.splitlines() 
    62                 x  = np.zeros(0) 
    63                 y  = np.zeros(0) 
    64                 dy = np.zeros(0) 
    65                 lam  = np.zeros(0) 
    66                 dlam = np.zeros(0) 
    67                 dx = np.zeros(0) 
    68                  
    69                #temp. space to sort data 
    70                 tx  = np.zeros(0) 
    71                 ty  = np.zeros(0) 
    72                 tdy = np.zeros(0) 
    73                 tlam  = np.zeros(0) 
    74                 tdlam = np.zeros(0) 
    75                 tdx = np.zeros(0) 
    76                 output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True) 
    77                 self.filename = output.filename = basename 
     51            if not (self.allow_all or extension.lower() in self.ext): 
     52                raise RuntimeError("{} has an unrecognized file extension".format(path)) 
     53        else: 
     54            raise RunetimeError("{} is not a file".format(path)) 
     55        with open(path, 'r') as input_f: 
     56            # Read in binary mode since GRASP frequently has no-ascii 
     57            # characters that brakes the open operation 
     58            line = input_f.readline() 
     59            params = {} 
     60            while line.strip() != "": 
     61                terms = line.strip().split("\t") 
     62                params[terms[0].strip()] = " ".join(terms[1:]).strip() 
     63                line = input_f.readline() 
     64            headers_temp = input_f.readline().strip().split("\t") 
     65            headers = {} 
     66            for h in headers_temp: 
     67                temp = h.strip().split() 
     68                headers[h[:-1].strip()] = temp[-1][1:-1] 
     69            data = np.loadtxt(input_f) 
     70            if data.size < 1: 
     71                raise RuntimeError("{} is empty".format(path)) 
     72            x = data[:, 0] 
     73            dx = data[:, 3] 
     74            lam = data[:, 4] 
     75            dlam = data[:, 5] 
     76            y = data[:, 1] 
     77            dy = data[:, 2] 
    7878 
    79                 paramnames=[] 
    80                 paramvals=[] 
    81                 zvals=[] 
    82                 dzvals=[] 
    83                 lamvals=[] 
    84                 dlamvals=[] 
    85                 Pvals=[] 
    86                 dPvals=[] 
     79            lam_unit = self._header_fetch(headers, "wavelength") 
     80            if lam_unit == "AA": 
     81                lam_unit = "A" 
    8782 
    88                 for line in lines: 
    89                     # Initial try for CSV (split on ,) 
    90                     line=line.strip() 
    91                     toks = line.split('\t') 
    92                     if len(toks)==2: 
    93                         paramnames.append(toks[0]) 
    94                         paramvals.append(toks[1]) 
    95                     if len(toks)>5: 
    96                         zvals.append(toks[0]) 
    97                         dzvals.append(toks[3]) 
    98                         lamvals.append(toks[4]) 
    99                         dlamvals.append(toks[5]) 
    100                         Pvals.append(toks[1]) 
    101                         dPvals.append(toks[2]) 
    102                     else: 
    103                         continue 
     83            x, x_unit = self._unit_conversion( 
     84                x, lam_unit, 
     85                self._fetch_unit(headers, "spin echo length")) 
     86            dx, dx_unit = self._unit_conversion( 
     87                dx, lam_unit, 
     88                self._fetch_unit(headers, "error SEL")) 
     89            dlam, dlam_unit = self._unit_conversion( 
     90                dlam, lam_unit, 
     91                self._fetch_unit(headers, "error wavelength")) 
     92            y_unit = r'\AA^{-2} cm^{-1}' 
    10493 
    105                 x=[] 
    106                 y=[] 
    107                 lam=[] 
    108                 dx=[] 
    109                 dy=[] 
    110                 dlam=[] 
    111                 lam_header = lamvals[0].split() 
    112                 data_conv_z = None 
    113                 default_z_unit = "A" 
    114                 data_conv_P = None 
    115                 default_p_unit = " " # Adjust unit for axis (L^-3) 
    116                 lam_unit = lam_header[1].replace("[","").replace("]","") 
    117                 if lam_unit == 'AA': 
    118                     lam_unit = 'A' 
    119                 varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]] 
    120                 valrange=range(1, len(zvals)) 
    121                 for i in valrange: 
    122                     x.append(float(zvals[i])) 
    123                     y.append(float(Pvals[i])) 
    124                     lam.append(float(lamvals[i])) 
    125                     dy.append(float(dPvals[i])) 
    126                     dx.append(float(dzvals[i])) 
    127                     dlam.append(float(dlamvals[i])) 
     94            output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, 
     95                            isSesans=True) 
     96            self.filename = output.filename = basename 
     97            output.xaxis(r"\rm{z}", x_unit) 
     98            # Adjust label to ln P/(lam^2 t), remove lam column refs 
     99            output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit) 
     100            # Store loading process information 
     101            output.meta_data['loader'] = self.type_name 
     102            output.sample.name = params["Sample"] 
     103            output.sample.ID = params["DataFileTitle"] 
    128104 
    129                 x,y,lam,dy,dx,dlam = [ 
    130                     np.asarray(v, 'double') 
    131                    for v in (x,y,lam,dy,dx,dlam) 
    132                 ] 
     105            output.sample.zacceptance = ( 
     106                float(self._header_fetch(params, "Q_zmax")), 
     107                self._fetch_unit(params, "Q_zmax")) 
    133108 
    134                 input_f.close() 
     109            output.sample.yacceptance = ( 
     110                float(self._header_fetch(params, "Q_ymax")), 
     111                self._fetch_unit(params, "Q_ymax")) 
     112            return output 
    135113 
    136                 output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit) 
    137                 output.y = y 
    138                 output.y_unit = r'\AA^{-2} cm^{-1}'  # output y_unit added 
    139                 output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit) 
    140                 output.dy = dy 
    141                 output.lam, output.lam_unit = self._unit_conversion(lam, lam_unit, default_z_unit) 
    142                 output.dlam, output.dlam_unit = self._unit_conversion(dlam, lam_unit, default_z_unit) 
    143                  
    144                 output.xaxis(r"\rm{z}", output.x_unit) 
    145                 output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", output.y_unit)  # Adjust label to ln P/(lam^2 t), remove lam column refs 
     114    @staticmethod 
     115    def _unit_conversion(value, value_unit, default_unit): 
     116        """ 
     117        Performs unit conversion on a measurement. 
    146118 
    147                 # Store loading process information 
    148                 output.meta_data['loader'] = self.type_name 
    149                 #output.sample.thickness = float(paramvals[6]) 
    150                 output.sample.name = paramvals[1] 
    151                 output.sample.ID = paramvals[0] 
    152                 zaccept_unit_split = paramnames[7].split("[") 
    153                 zaccept_unit = zaccept_unit_split[1].replace("]","") 
    154                 if zaccept_unit.strip() == r'\AA^-1' or zaccept_unit.strip() == r'\A^-1': 
    155                     zaccept_unit = "1/A" 
    156                 output.sample.zacceptance=(float(paramvals[7]),zaccept_unit) 
    157                 output.vars = varheader 
    158  
    159                 if len(output.x) < 1: 
    160                     raise RuntimeError, "%s is empty" % path 
    161                 return output 
    162  
    163         else: 
    164             raise RuntimeError, "%s is not a file" % path 
    165         return None 
    166  
    167     def _unit_conversion(self, value, value_unit, default_unit): 
    168         if has_converter == True and value_unit != default_unit: 
     119        :param value: The magnitude of the measurement 
     120        :param value_unit: a string containing the final desired unit 
     121        :param default_unit: a string containing the units of the original measurement 
     122        :return: The magnitude of the measurement in the new units 
     123        """ 
     124        # (float, string, string) -> float 
     125        if has_converter and value_unit != default_unit: 
    169126            data_conv_q = Converter(value_unit) 
    170127            value = data_conv_q(value, units=default_unit) 
    … …  
    173130            new_unit = value_unit 
    174131        return value, new_unit 
     132 
     133    @staticmethod 
     134    def _header_fetch(headers, key): 
     135        """ 
     136        Pull the value of a unit defined header from a dict. Example:: 
     137 
     138         d = {"Length [m]": 17} 
     139         self._header_fetch(d, "Length") == 17 
     140 
     141        :param header: A dictionary of values 
     142        :param key: A string which is a prefix for one of the keys in the dict 
     143        :return: The value of the dictionary for the specified key 
     144        """ 
     145        # (dict<string, x>, string) -> x 
     146        index = [k for k in headers.keys() 
     147                 if k.startswith(key)][0] 
     148        return headers[index] 
     149 
     150    @staticmethod 
     151    def _fetch_unit(params, key): 
     152        """ 
     153        Pull the unit off of a dictionary header. Example:: 
     154 
     155         d = {"Length [m]": 17} 
     156         self._fetch_unit(d, "Length") == "m" 
     157 
     158        :param header: A dictionary of values, where the keys are strings 
     159        with the units for the values appended onto the string within square 
     160        brackets (See the example above) 
     161        :param key: A string with the prefix of the dictionary key whose unit 
     162        is being fetched 
     163        :return: A string containing the unit specifed in the header 
     164        """ 
     165        # (dict<string, _>, string) -> string 
     166        index = [k for k in params.keys() 
     167                 if k.startswith(key)][0] 
     168        unit = index.strip().split()[-1][1:-1] 
     169        if unit.startswith(r"\A"): 
     170            unit = "1/A" 
     171        return unit 

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

    r9a5097c ra1b8fee  
    1616###################################################################### 
    1717 
     18from __future__ import print_function 
    1819 
    1920#TODO: Keep track of data manipulation in the 'process' data structure. 
    … …  
    353354    details = None 
    354355    ## SESANS zacceptance 
    355     zacceptance = None 
     356    zacceptance = (0,"") 
     357    yacceptance = (0,"") 
    356358 
    357359    def __init__(self): 
    … …  
    805807            # create zero vector 
    806808            dy_other = other.dy 
    807             if other.dy == None or (len(other.dy) != len(other.y)): 
     809            if other.dy is None or (len(other.dy) != len(other.y)): 
    808810                dy_other = np.zeros(len(other.y)) 
    809811 
    810812        # Check that we have errors, otherwise create zero vector 
    811813        dy = self.dy 
    812         if self.dy == None or (len(self.dy) != len(self.y)): 
     814        if self.dy is None or (len(self.dy) != len(self.y)): 
    813815            dy = np.zeros(len(self.y)) 
    814816 
    … …  
    821823        dy, dy_other = self._validity_check(other) 
    822824        result = self.clone_without_data(len(self.x)) 
    823         if self.dxw == None: 
     825        if self.dxw is None: 
    824826            result.dxw = None 
    825827        else: 
    826828            result.dxw = np.zeros(len(self.x)) 
    827         if self.dxl == None: 
     829        if self.dxl is None: 
    828830            result.dxl = None 
    829831        else: 
    … …  
    883885        self._validity_check_union(other) 
    884886        result = self.clone_without_data(len(self.x) + len(other.x)) 
    885         if self.dy == None or other.dy is None: 
     887        if self.dy is None or other.dy is None: 
    886888            result.dy = None 
    887889        else: 
    888890            result.dy = np.zeros(len(self.x) + len(other.x)) 
    889         if self.dx == None or other.dx is None: 
     891        if self.dx is None or other.dx is None: 
    890892            result.dx = None 
    891893        else: 
    892894            result.dx = np.zeros(len(self.x) + len(other.x)) 
    893         if self.dxw == None or other.dxw is None: 
     895        if self.dxw is None or other.dxw is None: 
    894896            result.dxw = None 
    895897        else: 
    896898            result.dxw = np.zeros(len(self.x) + len(other.x)) 
    897         if self.dxl == None or other.dxl is None: 
     899        if self.dxl is None or other.dxl is None: 
    898900            result.dxl = None 
    899901        else: 
    … …  
    906908        result.y = np.append(self.y, other.y) 
    907909        result.y = result.y[ind] 
    908         if result.dy != None: 
     910        if result.dy is not None: 
    909911            result.dy = np.append(self.dy, other.dy) 
    910912            result.dy = result.dy[ind] 
    … …  
    10291031            # Check that the scales match 
    10301032            err_other = other.err_data 
    1031             if other.err_data == None or \ 
     1033            if other.err_data is None or \ 
    10321034                (len(other.err_data) != len(other.data)): 
    10331035                err_other = np.zeros(len(other.data)) 
    … …  
    10351037        # Check that we have errors, otherwise create zero vector 
    10361038        err = self.err_data 
    1037         if self.err_data == None or \ 
     1039        if self.err_data is None or \ 
    10381040            (len(self.err_data) != len(self.data)): 
    10391041            err = np.zeros(len(other.data)) 
    … …  
    10501052        dy, dy_other = self._validity_check(other) 
    10511053        result = self.clone_without_data(np.size(self.data)) 
    1052         if self.dqx_data == None or self.dqy_data == None: 
     1054        if self.dqx_data is None or self.dqy_data is None: 
    10531055            result.dqx_data = None 
    10541056            result.dqy_data = None 
    … …  
    11241126        result.ymin = self.ymin 
    11251127        result.ymax = self.ymax 
    1126         if self.dqx_data == None or self.dqy_data == None or \ 
    1127                 other.dqx_data == None or other.dqy_data == None: 
     1128        if self.dqx_data is None or self.dqy_data is None or \ 
     1129                other.dqx_data is None or other.dqy_data is None: 
    11281130            result.dqx_data = None 
    11291131            result.dqy_data = None 

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

    rb699768 r463e7ffc  
    3232from readers import cansas_reader 
    3333 
     34logger = logging.getLogger(__name__) 
     35 
    3436class Registry(ExtensionRegistry): 
    3537    """ 
    … …  
    99101            msg = "DataLoader couldn't locate DataLoader plugin folder." 
    100102            msg += """ "%s" does not exist""" % dir 
    101             logging.warning(msg) 
     103            logger.warning(msg) 
    102104            return readers_found 
    103105 
    … …  
    117119                        msg = "Loader: Error importing " 
    118120                        msg += "%s\n  %s" % (item, sys.exc_value) 
    119                         logging.error(msg) 
     121                        logger.error(msg) 
    120122 
    121123                # Process zip files 
    … …  
    139141                                msg = "Loader: Error importing" 
    140142                                msg += " %s\n  %s" % (mfile, sys.exc_value) 
    141                                 logging.error(msg) 
     143                                logger.error(msg) 
    142144 
    143145                    except: 
    144146                        msg = "Loader: Error importing " 
    145147                        msg += " %s\n  %s" % (item, sys.exc_value) 
    146                         logging.error(msg) 
     148                        logger.error(msg) 
    147149 
    148150        return readers_found 
    … …  
    190192                msg = "Loader: Error accessing" 
    191193                msg += " Reader in %s\n  %s" % (module.__name__, sys.exc_value) 
    192                 logging.error(msg) 
     194                logger.error(msg) 
    193195        return reader_found 
    194196 
    … …  
    223225            msg = "Loader: Error accessing Reader " 
    224226            msg += "in %s\n  %s" % (loader.__name__, sys.exc_value) 
    225             logging.error(msg) 
     227            logger.error(msg) 
    226228        return reader_found 
    227229 
    … …  
    268270                msg = "Loader: Error accessing Reader" 
    269271                msg += " in %s\n  %s" % (module.__name__, sys.exc_value) 
    270                 logging.error(msg) 
     272                logger.error(msg) 
    271273        return reader_found 
    272274 

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

    rdd11014 r7432acb  
    210210            y[i_q] += frac * data[npts] 
    211211 
    212             if err_data == None or err_data[npts] == 0.0: 
     212            if err_data is None or err_data[npts] == 0.0: 
    213213                if data[npts] < 0: 
    214214                    data[npts] = -data[npts] 
    … …  
    333333                continue 
    334334            y += frac * data[npts] 
    335             if err_data == None or err_data[npts] == 0.0: 
     335            if err_data is None or err_data[npts] == 0.0: 
    336336                if data[npts] < 0: 
    337337                    data[npts] = -data[npts] 
    … …  
    422422 
    423423        # Get the dq for resolution averaging 
    424         if data2D.dqx_data != None and data2D.dqy_data != None: 
     424        if data2D.dqx_data is not None and data2D.dqy_data is not None: 
    425425            # The pinholes and det. pix contribution present 
    426426            # in both direction of the 2D which must be subtracted when 
    … …  
    462462 
    463463        #q_data_max = numpy.max(q_data) 
    464         if len(data2D.q_data) == None: 
     464        if len(data2D.q_data) is None: 
    465465            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data 
    466466            raise RuntimeError, msg 
    … …  
    502502            # Take dqs from data to get the q_average 
    503503            x[i_q] += frac * q_value 
    504             if err_data == None or err_data[npt] == 0.0: 
     504            if err_data is None or err_data[npt] == 0.0: 
    505505                if data_n < 0: 
    506506                    data_n = -data_n 
    … …  
    508508            else: 
    509509                err_y[i_q] += frac * frac * err_data[npt] * err_data[npt] 
    510             if dq_data != None: 
     510            if dq_data is not None: 
    511511                # To be consistent with dq calculation in 1d reduction, 
    512512                # we need just the averages (not quadratures) because 
    … …  
    523523                err_y[n] = -err_y[n] 
    524524            err_y[n] = math.sqrt(err_y[n]) 
    525             #if err_x != None: 
     525            #if err_x is not None: 
    526526            #    err_x[n] = math.sqrt(err_x[n]) 
    527527 
    … …  
    532532        idx = (numpy.isfinite(y)) & (numpy.isfinite(x)) 
    533533 
    534         if err_x != None: 
     534        if err_x is not None: 
    535535            d_x = err_x[idx] / y_counts[idx] 
    536536        else: 
    … …  
    623623            phi_bins[i_phi] += frac * data[npt] 
    624624 
    625             if err_data == None or err_data[npt] == 0.0: 
     625            if err_data is None or err_data[npt] == 0.0: 
    626626                if data_n < 0: 
    627627                    data_n = -data_n 
    … …  
    777777 
    778778        # Get the dq for resolution averaging 
    779         if data2D.dqx_data != None and data2D.dqy_data != None: 
     779        if data2D.dqx_data is not None and data2D.dqy_data is not None: 
    780780            # The pinholes and det. pix contribution present 
    781781            # in both direction of the 2D which must be subtracted when 
    … …  
    888888            y[i_bin] += frac * data_n 
    889889            x[i_bin] += frac * q_value 
    890             if err_data[n] == None or err_data[n] == 0.0: 
     890            if err_data[n] is None or err_data[n] == 0.0: 
    891891                if data_n < 0: 
    892892                    data_n = -data_n 
    … …  
    895895                y_err[i_bin] += frac * frac * err_data[n] * err_data[n] 
    896896 
    897             if dq_data != None: 
     897            if dq_data is not None: 
    898898                # To be consistent with dq calculation in 1d reduction, 
    899899                # we need just the averages (not quadratures) because 
    … …  
    925925        y_err[y_err == 0] = numpy.average(y_err) 
    926926        idx = (numpy.isfinite(y) & numpy.isfinite(y_err)) 
    927         if x_err != None: 
     927        if x_err is not None: 
    928928            d_x = x_err[idx] / y_counts[idx] 
    929929        else: 

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

    rdd11014 ra1b8fee  
    1212#copyright 2008, University of Tennessee 
    1313############################################################################# 
     14from __future__ import print_function 
     15 
    1416import os 
    1517 

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

    r9a5097c r235f514  
    128128                        if new_lentoks > 2: 
    129129                            _dy = float(toks[2]) 
    130                         has_error_dy = False if _dy == None else True 
     130                        has_error_dy = False if _dy is None else True 
    131131 
    132132                        # If a 4th row is present, consider it dx 
    133133                        if new_lentoks > 3: 
    134134                            _dx = float(toks[3]) 
    135                         has_error_dx = False if _dx == None else True 
     135                        has_error_dx = False if _dx is None else True 
    136136 
    137137                        # Delete the previously stored lines of data candidates if 

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

    re5c09cf ra1b8fee  
    1414#copyright 2009, University of Tennessee 
    1515############################################################################# 
     16from __future__ import print_function 
     17 
    1618import os 
    1719import sys 
    1820import logging 
    1921import json 
     22 
     23logger = logging.getLogger(__name__) 
    2024 
    2125FILE_NAME = 'defaults.json' 
    … …  
    6771                    msg = "read_associations: skipping association" 
    6872                    msg += " for %s\n  %s" % (ext.lower(), sys.exc_value) 
    69                     logging.error(msg) 
     73                    logger.error(msg) 
    7074    else: 
    71         print "Could not find reader association settings\n  %s [%s]" % (__file__, os.getcwd()) 
     75        print("Could not find reader association settings\n  %s [%s]" % (__file__, os.getcwd())) 
    7276          
    7377          
    … …  
    8185    :param registry_function: function to be called to register each reader 
    8286    """ 
    83     logging.info("register_readers is now obsolete: use read_associations()") 
     87    logger.info("register_readers is now obsolete: use read_associations()") 
    8488    import abs_reader 
    8589    import ascii_reader 

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

    rad4632c r63d773c  
    135135                             "Sesans": {"storeas": "content"}, 
    136136                             "zacceptance": {"storeas": "float"}, 
     137                             "yacceptance": {"storeas": "float"}, 
    137138                             "<any>" : ANY 
    138139                            } 

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

    r8434365 r7432acb  
    3333import xml.dom.minidom 
    3434from xml.dom.minidom import parseString 
     35 
     36logger = logging.getLogger(__name__) 
    3537 
    3638PREPROCESS = "xmlpreprocess" 
    … …  
    290292                elif tagname == 'Sesans': 
    291293                    self.current_datainfo.isSesans = bool(data_point) 
     294                elif tagname == 'yacceptance': 
     295                    self.current_datainfo.sample.yacceptance = (data_point, unit) 
    292296                elif tagname == 'zacceptance': 
    293297                    self.current_datainfo.sample.zacceptance = (data_point, unit) 
    … …  
    803807        :param data1d: presumably a Data1D object 
    804808        """ 
    805         if self.current_dataset == None: 
     809        if self.current_dataset is None: 
    806810            x_vals = np.empty(0) 
    807811            y_vals = np.empty(0) 
    … …  
    891895        # Write the file 
    892896        file_ref = open(filename, 'w') 
    893         if self.encoding == None: 
     897        if self.encoding is None: 
    894898            self.encoding = "UTF-8" 
    895899        doc.write(file_ref, encoding=self.encoding, 
    … …  
    10111015        :param entry_node: lxml node ElementTree object to be appended to 
    10121016        """ 
    1013         if datainfo.run == None or datainfo.run == []: 
     1017        if datainfo.run is None or datainfo.run == []: 
    10141018            datainfo.run.append(RUN_NAME_DEFAULT) 
    10151019            datainfo.run_name[RUN_NAME_DEFAULT] = RUN_NAME_DEFAULT 
    … …  
    10551059            sesans.text = str(datainfo.isSesans) 
    10561060            node.append(sesans) 
     1061            self.write_node(node, "yacceptance", datainfo.sample.yacceptance[0], 
     1062                             {'unit': datainfo.sample.yacceptance[1]}) 
    10571063            self.write_node(node, "zacceptance", datainfo.sample.zacceptance[0], 
    10581064                             {'unit': datainfo.sample.zacceptance[1]}) 
    … …  
    11271133                self.write_node(point, "T", spectrum.transmission[i], 
    11281134                                {'unit': spectrum.transmission_unit}) 
    1129                 if spectrum.transmission_deviation != None \ 
     1135                if spectrum.transmission_deviation is not None \ 
    11301136                and len(spectrum.transmission_deviation) >= i: 
    11311137                    self.write_node(point, "Tdev", 
    … …  
    12071213                                 str(datainfo.source.name)) 
    12081214        self.append(source, instr) 
    1209         if datainfo.source.radiation == None or datainfo.source.radiation == '': 
     1215        if datainfo.source.radiation is None or datainfo.source.radiation == '': 
    12101216            datainfo.source.radiation = "neutron" 
    12111217        self.write_node(source, "radiation", datainfo.source.radiation) 
    … …  
    12481254        :param instr: lxml node ElementTree object to be appended to 
    12491255        """ 
    1250         if datainfo.collimation == [] or datainfo.collimation == None: 
     1256        if datainfo.collimation == [] or datainfo.collimation is None: 
    12511257            coll = Collimation() 
    12521258            datainfo.collimation.append(coll) 
    … …  
    12931299        :param inst: lxml instrument node to be appended to 
    12941300        """ 
    1295         if datainfo.detector == None or datainfo.detector == []: 
     1301        if datainfo.detector is None or datainfo.detector == []: 
    12961302            det = Detector() 
    12971303            det.name = "" 
    … …  
    14581464                local_unit = None 
    14591465                exec "local_unit = storage.%s_unit" % toks[0] 
    1460                 if local_unit != None and units.lower() != local_unit.lower(): 
     1466                if local_unit is not None and units.lower() != local_unit.lower(): 
    14611467                    if HAS_CONVERTER == True: 
    14621468                        try: 
    … …  
    14711477                            self.errors.add(err_mess) 
    14721478                            if optional: 
    1473                                 logging.info(err_mess) 
     1479                                logger.info(err_mess) 
    14741480                            else: 
    14751481                                raise ValueError, err_mess 
    … …  
    14801486                        self.errors.add(err_mess) 
    14811487                        if optional: 
    1482                             logging.info(err_mess) 
     1488                            logger.info(err_mess) 
    14831489                        else: 
    14841490                            raise ValueError, err_mess 

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

    r9a5097c r235f514  
    1919from sas.sascalc.dataloader.data_info import Data2D, Detector 
    2020from sas.sascalc.dataloader.manipulations import reader2D_converter 
     21 
     22logger = logging.getLogger(__name__) 
    2123 
    2224# Look for unit converter 
    … …  
    142144                            error.append(err) 
    143145                        except: 
    144                             logging.info("Skipping line:%s,%s" %(data_str, 
     146                            logger.info("Skipping line:%s,%s" %(data_str, 
    145147                                                                sys.exc_value)) 
    146148             
    … …  
    164166                 
    165167                x_vals.append(qx) 
    166                 if xmin == None or qx < xmin: 
     168                if xmin is None or qx < xmin: 
    167169                    xmin = qx 
    168                 if xmax == None or qx > xmax: 
     170                if xmax is None or qx > xmax: 
    169171                    xmax = qx 
    170172             
    … …  
    179181                 
    180182                y_vals.append(qy) 
    181                 if ymin == None or qy < ymin: 
     183                if ymin is None or qy < ymin: 
    182184                    ymin = qy 
    183                 if ymax == None or qy > ymax: 
     185                if ymax is None or qy > ymax: 
    184186                    ymax = qy 
    185187             
    … …  
    196198                    msg = "Skipping entry (v1.0):%s,%s" % (str(data[i_pt]), 
    197199                                                           sys.exc_value) 
    198                     logging.info(msg) 
     200                    logger.info(msg) 
    199201                 
    200202                # Get bin number 
    … …  
    271273                raise ValueError, msg 
    272274            else: 
    273                 logging.info("Danse_reader Reading %s \n" % filename) 
     275                logger.info("Danse_reader Reading %s \n" % filename) 
    274276             
    275277            # Store loading process information 

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

    r9a5097c ra1b8fee  
    99#copyright 2008, University of Tennessee 
    1010###################################################################### 
     11from __future__ import print_function 
     12 
    1113import os 
    1214import numpy as np 
    … …  
    8284        detector = Detector() 
    8385        if len(output.detector) > 0: 
    84             print str(output.detector[0]) 
     86            print(str(output.detector[0])) 
    8587        output.detector.append(detector) 
    8688                 

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

    r9a5097c r959eb01  
    1616from sas.sascalc.dataloader.data_info import Data2D 
    1717from sas.sascalc.dataloader.manipulations import reader2D_converter 
    18      
     18 
     19logger = logging.getLogger(__name__) 
     20 
    1921class Reader: 
    2022    """ 
    … …  
    7678                value = float(val) 
    7779            except: 
    78                 logging.error("tiff_reader: had to skip a non-float point") 
     80                logger.error("tiff_reader: had to skip a non-float point") 
    7981                continue 
    8082             

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

    ra235f715 r235f514  
    1818from lxml import etree 
    1919from lxml.builder import E 
     20 
     21logger = logging.getLogger(__name__) 
    2022 
    2123PARSER = etree.ETCompatXMLParser(remove_comments=True, remove_pis=False) 
    … …  
    7173            self.xmlroot = self.xmldoc.getroot() 
    7274        except etree.XMLSyntaxError as xml_error: 
    73             logging.info(xml_error) 
     75            logger.info(xml_error) 
    7476        except Exception: 
    7577            self.xml = None 
    … …  
    8890            self.xmlroot = etree.fromstring(tag_soup) 
    8991        except etree.XMLSyntaxError as xml_error: 
    90             logging.info(xml_error) 
     92            logger.info(xml_error) 
    9193        except Exception: 
    9294            self.xml = None 
    … …  
    102104            self.schemadoc = etree.parse(self.schema, parser=PARSER) 
    103105        except etree.XMLSyntaxError as xml_error: 
    104             logging.info(xml_error) 
     106            logger.info(xml_error) 
    105107        except Exception: 
    106108            self.schema = None 
    … …  
    238240        :param name: The name of the element to be created 
    239241        """ 
    240         if attrib == None: 
     242        if attrib is None: 
    241243            attrib = {} 
    242244        return etree.Element(name, attrib, nsmap) 
    … …  
    297299        """ 
    298300        text = str(text) 
    299         if attrib == None: 
     301        if attrib is None: 
    300302            attrib = {} 
    301303        elem = E(elementname, attrib, text) 
Note: See TracChangeset for help on using the changeset viewer.