Changeset 6a455cd3 in sasview for src/sas/sascalc/dataloader/readers


Ignore:
Timestamp:
Jul 24, 2017 10:27:05 AM (7 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, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
146c669
Parents:
b61bd57 (diff), bc04647 (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.
Message:

Merge branch 'master' into 4_1_issues

# Conflicts:
# docs/sphinx-docs/source/conf.py
# src/sas/sascalc/dataloader/readers/cansas_reader.py
# src/sas/sasgui/guiframe/documentation_window.py
# src/sas/sasgui/perspectives/fitting/models.py

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

Legend:

Unmodified
Added
Removed

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

    rb699768 ra1b8fee  
    1212#copyright 2008, University of Tennessee 
    1313############################################################################# 
     14from __future__ import print_function 
     15 
    1416import os 
    15 import numpy 
    16 import math 
    17 #import logging 
     17 
    1818from sas.sascalc.dataloader.data_info import Data2D 
    1919from sas.sascalc.dataloader.data_info import Detector 
    2020from sas.sascalc.dataloader.manipulations import reader2D_converter 
     21import numpy as np 
    2122 
    2223# Look for unit converter 
    … …  
    4041        """ Read file """ 
    4142        if not os.path.isfile(filename): 
    42             raise ValueError, \ 
    43             "Specified file %s is not a regular file" % filename 
    44          
    45         # Read file 
    46         f = open(filename, 'r') 
    47         buf = f.read() 
    48          
    49         # Instantiate data object 
     43            raise ValueError("Specified file %s is not a regular " 
     44                             "file" % filename) 
     45         
    5046        output = Data2D() 
     47 
    5148        output.filename = os.path.basename(filename) 
    5249        detector = Detector() 
    53         if len(output.detector) > 0: 
    54             print str(output.detector[0]) 
     50        if len(output.detector): 
     51            print(str(output.detector[0])) 
    5552        output.detector.append(detector) 
    56                  
    57         # Get content 
    58         dataStarted = False 
    59          
    60         lines = buf.split('\n') 
    61         itot = 0 
    62         x = [] 
    63         y = [] 
    64          
    65         ncounts = 0 
    66          
    67         xmin = None 
    68         xmax = None 
    69         ymin = None 
    70         ymax = None 
    71          
    72         i_x = 0 
    73         i_y = -1 
    74         i_tot_row = 0 
    75          
    76         isInfo = False 
    77         isCenter = False 
    78         
    79         data_conv_q = None 
    80         data_conv_i = None 
    81          
    82         if has_converter == True and output.Q_unit != '1/A': 
     53 
     54        data_conv_q = data_conv_i = None 
     55         
     56        if has_converter and output.Q_unit != '1/A': 
    8357            data_conv_q = Converter('1/A') 
    8458            # Test it 
    8559            data_conv_q(1.0, output.Q_unit) 
    8660             
    87         if has_converter == True and output.I_unit != '1/cm': 
     61        if has_converter and output.I_unit != '1/cm': 
    8862            data_conv_i = Converter('1/cm') 
    8963            # Test it 
    9064            data_conv_i(1.0, output.I_unit) 
    91           
    92         for line in lines: 
    93              
    94             # Find setup info line 
    95             if isInfo: 
    96                 isInfo = False 
    97                 line_toks = line.split() 
    98                 # Wavelength in Angstrom 
    99                 try: 
    100                     wavelength = float(line_toks[1]) 
    101                 except: 
    102                     msg = "IgorReader: can't read this file, missing wavelength" 
    103                     raise ValueError, msg 
    104                  
    105             #Find # of bins in a row assuming the detector is square. 
    106             if dataStarted == True: 
    107                 try: 
    108                     value = float(line) 
    109                 except: 
    110                     # Found a non-float entry, skip it 
    111                     continue 
    112                  
    113                 # Get total bin number 
    114                  
    115             i_tot_row += 1 
    116         i_tot_row = math.ceil(math.sqrt(i_tot_row)) - 1 
    117         #print "i_tot", i_tot_row 
    118         size_x = i_tot_row  # 192#128 
    119         size_y = i_tot_row  # 192#128 
    120         output.data = numpy.zeros([size_x, size_y]) 
    121         output.err_data = numpy.zeros([size_x, size_y]) 
    122       
    123         #Read Header and 2D data 
    124         for line in lines: 
    125             # Find setup info line 
    126             if isInfo: 
    127                 isInfo = False 
    128                 line_toks = line.split() 
    129                 # Wavelength in Angstrom 
    130                 try: 
    131                     wavelength = float(line_toks[1]) 
    132                 except: 
    133                     msg = "IgorReader: can't read this file, missing wavelength" 
    134                     raise ValueError, msg 
    135                 # Distance in meters 
    136                 try: 
    137                     distance = float(line_toks[3]) 
    138                 except: 
    139                     msg = "IgorReader: can't read this file, missing distance" 
    140                     raise ValueError, msg 
    141                  
    142                 # Distance in meters 
    143                 try: 
    144                     transmission = float(line_toks[4]) 
    145                 except: 
    146                     msg = "IgorReader: can't read this file, " 
    147                     msg += "missing transmission" 
    148                     raise ValueError, msg 
    149                                              
    150             if line.count("LAMBDA") > 0: 
    151                 isInfo = True 
    152                  
    153             # Find center info line 
    154             if isCenter: 
    155                 isCenter = False 
    156                 line_toks = line.split() 
    157                  
    158                 # Center in bin number: Must substrate 1 because 
    159                 #the index starts from 1 
    160                 center_x = float(line_toks[0]) - 1 
    161                 center_y = float(line_toks[1]) - 1 
    162  
    163             if line.count("BCENT") > 0: 
    164                 isCenter = True 
    165                  
    166             # Find data start 
    167             if line.count("***")>0: 
    168                 dataStarted = True 
    169                  
    170                 # Check that we have all the info 
    171                 if wavelength == None \ 
    172                     or distance == None \ 
    173                     or center_x == None \ 
    174                     or center_y == None: 
    175                     msg = "IgorReader:Missing information in data file" 
    176                     raise ValueError, msg 
    177                  
    178             if dataStarted == True: 
    179                 try: 
    180                     value = float(line) 
    181                 except: 
    182                     # Found a non-float entry, skip it 
    183                     continue 
    184                  
    185                 # Get bin number 
    186                 if math.fmod(itot, i_tot_row) == 0: 
    187                     i_x = 0 
    188                     i_y += 1 
    189                 else: 
    190                     i_x += 1 
    191                      
    192                 output.data[i_y][i_x] = value 
    193                 ncounts += 1 
    194                  
    195                 # Det 640 x 640 mm 
    196                 # Q = 4pi/lambda sin(theta/2) 
    197                 # Bin size is 0.5 cm  
    198                 #REmoved +1 from theta = (i_x-center_x+1)*0.5 / distance 
    199                 # / 100.0 and  
    200                 #REmoved +1 from theta = (i_y-center_y+1)*0.5 / 
    201                 # distance / 100.0 
    202                 #ToDo: Need  complete check if the following 
    203                 # covert process is consistent with fitting.py. 
    204                 theta = (i_x - center_x) * 0.5 / distance / 100.0 
    205                 qx = 4.0 * math.pi / wavelength * math.sin(theta/2.0) 
    206  
    207                 if has_converter == True and output.Q_unit != '1/A': 
    208                     qx = data_conv_q(qx, units=output.Q_unit) 
    209  
    210                 if xmin == None or qx < xmin: 
    211                     xmin = qx 
    212                 if xmax == None or qx > xmax: 
    213                     xmax = qx 
    214                  
    215                 theta = (i_y - center_y) * 0.5 / distance / 100.0 
    216                 qy = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
    217  
    218                 if has_converter == True and output.Q_unit != '1/A': 
    219                     qy = data_conv_q(qy, units=output.Q_unit) 
    220                  
    221                 if ymin == None or qy < ymin: 
    222                     ymin = qy 
    223                 if ymax == None or qy > ymax: 
    224                     ymax = qy 
    225                  
    226                 if not qx in x: 
    227                     x.append(qx) 
    228                 if not qy in y: 
    229                     y.append(qy) 
    230                  
    231                 itot += 1 
    232                    
    233                    
     65 
     66        data_row = 0 
     67        wavelength = distance = center_x = center_y = None 
     68        dataStarted = isInfo = isCenter = False 
     69 
     70        with open(filename, 'r') as f: 
     71            for line in f: 
     72                data_row += 1 
     73                # Find setup info line 
     74                if isInfo: 
     75                    isInfo = False 
     76                    line_toks = line.split() 
     77                    # Wavelength in Angstrom 
     78                    try: 
     79                        wavelength = float(line_toks[1]) 
     80                    except ValueError: 
     81                        msg = "IgorReader: can't read this file, missing wavelength" 
     82                        raise ValueError(msg) 
     83                    # Distance in meters 
     84                    try: 
     85                        distance = float(line_toks[3]) 
     86                    except ValueError: 
     87                        msg = "IgorReader: can't read this file, missing distance" 
     88                        raise ValueError(msg) 
     89 
     90                    # Distance in meters 
     91                    try: 
     92                        transmission = float(line_toks[4]) 
     93                    except: 
     94                        msg = "IgorReader: can't read this file, " 
     95                        msg += "missing transmission" 
     96                        raise ValueError(msg) 
     97 
     98                if line.count("LAMBDA"): 
     99                    isInfo = True 
     100 
     101                # Find center info line 
     102                if isCenter: 
     103                    isCenter = False 
     104                    line_toks = line.split() 
     105 
     106                    # Center in bin number: Must subtract 1 because 
     107                    # the index starts from 1 
     108                    center_x = float(line_toks[0]) - 1 
     109                    center_y = float(line_toks[1]) - 1 
     110 
     111                if line.count("BCENT"): 
     112                    isCenter = True 
     113 
     114                # Find data start 
     115                if line.count("***"): 
     116                    # now have to continue to blank line 
     117                    dataStarted = True 
     118 
     119                    # Check that we have all the info 
     120                    if (wavelength is None 
     121                            or distance is None 
     122                            or center_x is None 
     123                            or center_y is None): 
     124                        msg = "IgorReader:Missing information in data file" 
     125                        raise ValueError(msg) 
     126 
     127                if dataStarted: 
     128                    if len(line.rstrip()): 
     129                        continue 
     130                    else: 
     131                        break 
     132 
     133        # The data is loaded in row major order (last index changing most 
     134        # rapidly). However, the original data is in column major order (first 
     135        # index changing most rapidly). The swap to column major order is done 
     136        # in reader2D_converter at the end of this method. 
     137        data = np.loadtxt(filename, skiprows=data_row) 
     138        size_x = size_y = int(np.rint(np.sqrt(data.size))) 
     139        output.data = np.reshape(data, (size_x, size_y)) 
     140        output.err_data = np.zeros_like(output.data) 
     141 
     142        # Det 640 x 640 mm 
     143        # Q = 4 * pi/lambda * sin(theta/2) 
     144        # Bin size is 0.5 cm 
     145        # Removed +1 from theta = (i_x - center_x + 1)*0.5 / distance 
     146        # / 100.0 and 
     147        # Removed +1 from theta = (i_y - center_y + 1)*0.5 / 
     148        # distance / 100.0 
     149        # ToDo: Need  complete check if the following 
     150        # convert process is consistent with fitting.py. 
     151 
     152        # calculate qx, qy bin centers of each pixel in the image 
     153        theta = (np.arange(size_x) - center_x) * 0.5 / distance / 100. 
     154        qx = 4 * np.pi / wavelength * np.sin(theta/2) 
     155 
     156        theta = (np.arange(size_y) - center_y) * 0.5 / distance / 100. 
     157        qy = 4 * np.pi / wavelength * np.sin(theta/2) 
     158 
     159        if has_converter and output.Q_unit != '1/A': 
     160            qx = data_conv_q(qx, units=output.Q_unit) 
     161            qy = data_conv_q(qx, units=output.Q_unit) 
     162 
     163        xmax = np.max(qx) 
     164        xmin = np.min(qx) 
     165        ymax = np.max(qy) 
     166        ymin = np.min(qy) 
     167 
     168        # calculate edge offset in q. 
    234169        theta = 0.25 / distance / 100.0 
    235         xstep = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
     170        xstep = 4.0 * np.pi / wavelength * np.sin(theta / 2.0) 
    236171         
    237172        theta = 0.25 / distance / 100.0 
    238         ystep = 4.0 * math.pi/ wavelength * math.sin(theta / 2.0) 
     173        ystep = 4.0 * np.pi/ wavelength * np.sin(theta / 2.0) 
    239174         
    240175        # Store all data ###################################### 
    241176        # Store wavelength 
    242         if has_converter == True and output.source.wavelength_unit != 'A': 
     177        if has_converter and output.source.wavelength_unit != 'A': 
    243178            conv = Converter('A') 
    244179            wavelength = conv(wavelength, units=output.source.wavelength_unit) 
    … …  
    246181 
    247182        # Store distance 
    248         if has_converter == True and detector.distance_unit != 'm': 
     183        if has_converter and detector.distance_unit != 'm': 
    249184            conv = Converter('m') 
    250185            distance = conv(distance, units=detector.distance_unit) 
    … …  
    254189        output.sample.transmission = transmission 
    255190         
    256         # Store pixel size 
     191        # Store pixel size (mm) 
    257192        pixel = 5.0 
    258         if has_converter == True and detector.pixel_size_unit != 'mm': 
     193        if has_converter and detector.pixel_size_unit != 'mm': 
    259194            conv = Converter('mm') 
    260195            pixel = conv(pixel, units=detector.pixel_size_unit) 
    … …  
    267202         
    268203        # Store limits of the image (2D array) 
    269         xmin = xmin - xstep / 2.0 
    270         xmax = xmax + xstep / 2.0 
    271         ymin = ymin - ystep / 2.0 
    272         ymax = ymax + ystep / 2.0 
    273         if has_converter == True and output.Q_unit != '1/A': 
     204        xmin -= xstep / 2.0 
     205        xmax += xstep / 2.0 
     206        ymin -= ystep / 2.0 
     207        ymax += ystep / 2.0 
     208        if has_converter and output.Q_unit != '1/A': 
    274209            xmin = data_conv_q(xmin, units=output.Q_unit) 
    275210            xmax = data_conv_q(xmax, units=output.Q_unit) 
    … …  
    282217         
    283218        # Store x and y axis bin centers 
    284         output.x_bins = x 
    285         output.y_bins = y 
     219        output.x_bins = qx.tolist() 
     220        output.y_bins = qy.tolist() 
    286221         
    287222        # Units 

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

    rb699768 r959eb01  
    99###################################################################### 
    1010 
    11 import numpy 
     11import numpy as np 
    1212import os 
    1313from sas.sascalc.dataloader.data_info import Data1D 
    … …  
    5353                buff = input_f.read() 
    5454                lines = buff.split('\n') 
    55                 x  = numpy.zeros(0) 
    56                 y  = numpy.zeros(0) 
    57                 dy = numpy.zeros(0) 
    58                 dx = numpy.zeros(0) 
     55                x  = np.zeros(0) 
     56                y  = np.zeros(0) 
     57                dy = np.zeros(0) 
     58                dx = np.zeros(0) 
    5959                output = Data1D(x, y, dy=dy, dx=dx) 
    6060                detector = Detector() 
    … …  
    204204                                _dy = data_conv_i(_dy, units=output.y_unit) 
    205205                            
    206                             x = numpy.append(x, _x) 
    207                             y = numpy.append(y, _y) 
    208                             dy = numpy.append(dy, _dy) 
    209                             dx = numpy.append(dx, _dx) 
     206                            x = np.append(x, _x) 
     207                            y = np.append(y, _y) 
     208                            dy = np.append(dy, _dy) 
     209                            dx = np.append(dx, _dx) 
    210210                             
    211211                        except: 

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

    rd2471870 r235f514  
    1414 
    1515 
    16 import numpy 
     16import numpy as np 
    1717import os 
    1818from sas.sascalc.dataloader.data_info import Data1D 
    … …  
    6969 
    7070                # Arrays for data storage 
    71                 tx = numpy.zeros(0) 
    72                 ty = numpy.zeros(0) 
    73                 tdy = numpy.zeros(0) 
    74                 tdx = numpy.zeros(0) 
     71                tx = np.zeros(0) 
     72                ty = np.zeros(0) 
     73                tdy = np.zeros(0) 
     74                tdx = np.zeros(0) 
    7575 
    7676                # The first good line of data will define whether 
    … …  
    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 
    … …  
    140140                            is_data == False: 
    141141                            try: 
    142                                 tx = numpy.zeros(0) 
    143                                 ty = numpy.zeros(0) 
    144                                 tdy = numpy.zeros(0) 
    145                                 tdx = numpy.zeros(0) 
     142                                tx = np.zeros(0) 
     143                                ty = np.zeros(0) 
     144                                tdy = np.zeros(0) 
     145                                tdx = np.zeros(0) 
    146146                            except: 
    147147                                pass 
    148148 
    149149                        if has_error_dy == True: 
    150                             tdy = numpy.append(tdy, _dy) 
     150                            tdy = np.append(tdy, _dy) 
    151151                        if has_error_dx == True: 
    152                             tdx = numpy.append(tdx, _dx) 
    153                         tx = numpy.append(tx, _x) 
    154                         ty = numpy.append(ty, _y) 
     152                            tdx = np.append(tdx, _dx) 
     153                        tx = np.append(tx, _x) 
     154                        ty = np.append(ty, _y) 
    155155 
    156156                        #To remember the # of columns on the current line 
    … …  
    188188                #Let's re-order the data to make cal. 
    189189                # curve look better some cases 
    190                 ind = numpy.lexsort((ty, tx)) 
    191                 x = numpy.zeros(len(tx)) 
    192                 y = numpy.zeros(len(ty)) 
    193                 dy = numpy.zeros(len(tdy)) 
    194                 dx = numpy.zeros(len(tdx)) 
     190                ind = np.lexsort((ty, tx)) 
     191                x = np.zeros(len(tx)) 
     192                y = np.zeros(len(ty)) 
     193                dy = np.zeros(len(tdy)) 
     194                dx = np.zeros(len(tdx)) 
    195195                output = Data1D(x, y, dy=dy, dx=dx) 
    196196                self.filename = output.filename = basename 
    … …  
    212212                output.y = y[x != 0] 
    213213                output.dy = dy[x != 0] if has_error_dy == True\ 
    214                     else numpy.zeros(len(output.y)) 
     214                    else np.zeros(len(output.y)) 
    215215                output.dx = dx[x != 0] if has_error_dx == True\ 
    216                     else numpy.zeros(len(output.x)) 
     216                    else np.zeros(len(output.x)) 
    217217 
    218218                output.xaxis("\\rm{Q}", 'A^{-1}') 

  • 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

    r527a190 r6a455cd3  
    3333import xml.dom.minidom 
    3434from xml.dom.minidom import parseString 
     35 
     36logger = logging.getLogger(__name__) 
    3537 
    3638PREPROCESS = "xmlpreprocess" 
    … …  
    285287                    self.current_dataset.yaxis(attr.get('y_axis'), 
    286288                                                attr.get('y_unit')) 
     289                elif tagname == 'yacceptance': 
     290                    self.current_datainfo.sample.yacceptance = (data_point, unit) 
    287291                elif tagname == 'zacceptance': 
    288292                    self.current_datainfo.sample.zacceptance = (data_point, unit) 
    … …  
    801805        :param data1d: presumably a Data1D object 
    802806        """ 
    803         if self.current_dataset == None: 
     807        if self.current_dataset is None: 
    804808            x_vals = np.empty(0) 
    805809            y_vals = np.empty(0) 
    … …  
    889893        # Write the file 
    890894        file_ref = open(filename, 'w') 
    891         if self.encoding == None: 
     895        if self.encoding is None: 
    892896            self.encoding = "UTF-8" 
    893897        doc.write(file_ref, encoding=self.encoding, 
    … …  
    10091013        :param entry_node: lxml node ElementTree object to be appended to 
    10101014        """ 
    1011         if datainfo.run == None or datainfo.run == []: 
     1015        if datainfo.run is None or datainfo.run == []: 
    10121016            datainfo.run.append(RUN_NAME_DEFAULT) 
    10131017            datainfo.run_name[RUN_NAME_DEFAULT] = RUN_NAME_DEFAULT 
    … …  
    10571061            sesans.text = str(datainfo.isSesans) 
    10581062            entry_node.append(sesans) 
     1063            self.write_node(entry_node, "yacceptance", datainfo.sample.yacceptance[0], 
     1064                             {'unit': datainfo.sample.yacceptance[1]}) 
    10591065            self.write_node(entry_node, "zacceptance", datainfo.sample.zacceptance[0], 
    10601066                             {'unit': datainfo.sample.zacceptance[1]}) 
    … …  
    11291135                self.write_node(point, "T", spectrum.transmission[i], 
    11301136                                {'unit': spectrum.transmission_unit}) 
    1131                 if spectrum.transmission_deviation != None \ 
     1137                if spectrum.transmission_deviation is not None \ 
    11321138                and len(spectrum.transmission_deviation) >= i: 
    11331139                    self.write_node(point, "Tdev", 
    … …  
    12091215                                 str(datainfo.source.name)) 
    12101216        self.append(source, instr) 
    1211         if datainfo.source.radiation == None or datainfo.source.radiation == '': 
     1217        if datainfo.source.radiation is None or datainfo.source.radiation == '': 
    12121218            datainfo.source.radiation = "neutron" 
    12131219        self.write_node(source, "radiation", datainfo.source.radiation) 
    … …  
    12501256        :param instr: lxml node ElementTree object to be appended to 
    12511257        """ 
    1252         if datainfo.collimation == [] or datainfo.collimation == None: 
     1258        if datainfo.collimation == [] or datainfo.collimation is None: 
    12531259            coll = Collimation() 
    12541260            datainfo.collimation.append(coll) 
    … …  
    12951301        :param inst: lxml instrument node to be appended to 
    12961302        """ 
    1297         if datainfo.detector == None or datainfo.detector == []: 
     1303        if datainfo.detector is None or datainfo.detector == []: 
    12981304            det = Detector() 
    12991305            det.name = "" 
    … …  
    14601466                local_unit = None 
    14611467                exec "local_unit = storage.%s_unit" % toks[0] 
    1462                 if local_unit != None and units.lower() != local_unit.lower(): 
     1468                if local_unit is not None and units.lower() != local_unit.lower(): 
    14631469                    if HAS_CONVERTER == True: 
    14641470                        try: 
    … …  
    14731479                            self.errors.add(err_mess) 
    14741480                            if optional: 
    1475                                 logging.info(err_mess) 
     1481                                logger.info(err_mess) 
    14761482                            else: 
    14771483                                raise ValueError, err_mess 
    … …  
    14821488                        self.errors.add(err_mess) 
    14831489                        if optional: 
    1484                             logging.info(err_mess) 
     1490                            logger.info(err_mess) 
    14851491                        else: 
    14861492                            raise ValueError, err_mess 

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

    rb699768 r235f514  
    1515import os 
    1616import sys 
    17 import numpy 
     17import numpy as np 
    1818import logging 
    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 
    … …  
    7981            output.detector.append(detector) 
    8082             
    81             output.data = numpy.zeros([size_x,size_y]) 
    82             output.err_data = numpy.zeros([size_x, size_y]) 
     83            output.data = np.zeros([size_x,size_y]) 
     84            output.err_data = np.zeros([size_x, size_y]) 
    8385             
    8486            data_conv_q = None 
    … …  
    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/hfir1d_reader.py

    rb699768 r959eb01  
    99#copyright 2008, University of Tennessee 
    1010###################################################################### 
    11 import numpy 
     11import numpy as np 
    1212import os 
    1313from sas.sascalc.dataloader.data_info import Data1D 
    … …  
    5252                buff = input_f.read() 
    5353                lines = buff.split('\n') 
    54                 x = numpy.zeros(0) 
    55                 y = numpy.zeros(0) 
    56                 dx = numpy.zeros(0) 
    57                 dy = numpy.zeros(0) 
     54                x = np.zeros(0) 
     55                y = np.zeros(0) 
     56                dx = np.zeros(0) 
     57                dy = np.zeros(0) 
    5858                output = Data1D(x, y, dx=dx, dy=dy) 
    5959                self.filename = output.filename = basename 
    … …  
    8888                            _dy = data_conv_i(_dy, units=output.y_unit) 
    8989                                                     
    90                         x = numpy.append(x, _x) 
    91                         y = numpy.append(y, _y) 
    92                         dx = numpy.append(dx, _dx) 
    93                         dy = numpy.append(dy, _dy) 
     90                        x = np.append(x, _x) 
     91                        y = np.append(y, _y) 
     92                        dx = np.append(dx, _dx) 
     93                        dy = np.append(dy, _dy) 
    9494                    except: 
    9595                        # Couldn't parse this line, skip it  

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

    rb699768 ra1b8fee  
    99#copyright 2008, University of Tennessee 
    1010###################################################################### 
     11from __future__ import print_function 
     12 
    1113import os 
    12 import numpy 
     14import numpy as np 
    1315import math 
    1416from sas.sascalc.dataloader.data_info import Data2D, Detector 
    … …  
    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                 
    … …  
    198200                break 
    199201        # Make numpy array to remove header lines using index 
    200         lines_array = numpy.array(lines) 
     202        lines_array = np.array(lines) 
    201203 
    202204        # index for lines_array 
    203         lines_index = numpy.arange(len(lines)) 
     205        lines_index = np.arange(len(lines)) 
    204206         
    205207        # get the data lines 
    … …  
    225227 
    226228        # numpy array form 
    227         data_array = numpy.array(data_list1) 
     229        data_array = np.array(data_list1) 
    228230        # Redimesion based on the row_num and col_num, 
    229231        #otherwise raise an error. 
    … …  
    235237        ## Get the all data: Let's HARDcoding; Todo find better way 
    236238        # Defaults 
    237         dqx_data = numpy.zeros(0) 
    238         dqy_data = numpy.zeros(0) 
    239         err_data = numpy.ones(row_num) 
    240         qz_data = numpy.zeros(row_num) 
    241         mask = numpy.ones(row_num, dtype=bool) 
     239        dqx_data = np.zeros(0) 
     240        dqy_data = np.zeros(0) 
     241        err_data = np.ones(row_num) 
     242        qz_data = np.zeros(row_num) 
     243        mask = np.ones(row_num, dtype=bool) 
    242244        # Get from the array 
    243245        qx_data = data_point[0] 
    … …  
    254256            dqy_data = data_point[(5 + ver)] 
    255257        #if col_num > (6 + ver): mask[data_point[(6 + ver)] < 1] = False 
    256         q_data = numpy.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data) 
     258        q_data = np.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data) 
    257259            
    258260        # Extra protection(it is needed for some data files):  
    … …  
    262264   
    263265        # Store limits of the image in q space 
    264         xmin = numpy.min(qx_data) 
    265         xmax = numpy.max(qx_data) 
    266         ymin = numpy.min(qy_data) 
    267         ymax = numpy.max(qy_data) 
     266        xmin = np.min(qx_data) 
     267        xmax = np.max(qx_data) 
     268        ymin = np.min(qy_data) 
     269        ymax = np.max(qy_data) 
    268270 
    269271        # units 
    … …  
    287289         
    288290        # store x and y axis bin centers in q space 
    289         x_bins = numpy.arange(xmin, xmax + xstep, xstep) 
    290         y_bins = numpy.arange(ymin, ymax + ystep, ystep) 
     291        x_bins = np.arange(xmin, xmax + xstep, xstep) 
     292        y_bins = np.arange(ymin, ymax + ystep, ystep) 
    291293        
    292294        # get the limits of q values 
    … …  
    300302        output.data = data 
    301303        if (err_data == 1).all(): 
    302             output.err_data = numpy.sqrt(numpy.abs(data)) 
     304            output.err_data = np.sqrt(np.abs(data)) 
    303305            output.err_data[output.err_data == 0.0] = 1.0 
    304306        else: 
    … …  
    335337                # tranfer the comp. to cartesian coord. for newer version. 
    336338                if ver != 1: 
    337                     diag = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     339                    diag = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    338340                    cos_th = qx_data / diag 
    339341                    sin_th = qy_data / diag 
    340                     output.dqx_data = numpy.sqrt((dqx_data * cos_th) * \ 
     342                    output.dqx_data = np.sqrt((dqx_data * cos_th) * \ 
    341343                                                 (dqx_data * cos_th) \ 
    342344                                                 + (dqy_data * sin_th) * \ 
    343345                                                  (dqy_data * sin_th)) 
    344                     output.dqy_data = numpy.sqrt((dqx_data * sin_th) * \ 
     346                    output.dqy_data = np.sqrt((dqx_data * sin_th) * \ 
    345347                                                 (dqx_data * sin_th) \ 
    346348                                                 + (dqy_data * cos_th) * \ 

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

    r7caf3e5 r149b8f6  
    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""" 
    8 import numpy 
     8import numpy as np 
    99import os 
    1010from sas.sascalc.dataloader.data_info import Data1D 
    … …  
    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  = numpy.zeros(0) 
    63                 y  = numpy.zeros(0) 
    64                 dy = numpy.zeros(0) 
    65                 lam  = numpy.zeros(0) 
    66                 dlam = numpy.zeros(0) 
    67                 dx = numpy.zeros(0) 
    68                  
    69                #temp. space to sort data 
    70                 tx  = numpy.zeros(0) 
    71                 ty  = numpy.zeros(0) 
    72                 tdy = numpy.zeros(0) 
    73                 tlam  = numpy.zeros(0) 
    74                 tdlam = numpy.zeros(0) 
    75                 tdx = numpy.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( 
     53                    "{} has an unrecognized file extension".format(path)) 
     54        else: 
     55            raise RuntimeError("{} is not a file".format(path)) 
     56        with open(path, 'r') as input_f: 
     57            line = input_f.readline() 
     58            params = {} 
     59            while not line.startswith("BEGIN_DATA"): 
     60                terms = line.split() 
     61                if len(terms) >= 2: 
     62                    params[terms[0]] = " ".join(terms[1:]) 
     63                line = input_f.readline() 
     64            self.params = params 
    7865 
    79                 paramnames=[] 
    80                 paramvals=[] 
    81                 zvals=[] 
    82                 dzvals=[] 
    83                 lamvals=[] 
    84                 dlamvals=[] 
    85                 Pvals=[] 
    86                 dPvals=[] 
     66            if "FileFormatVersion" not in self.params: 
     67                raise RuntimeError("SES file missing FileFormatVersion") 
     68            if float(self.params["FileFormatVersion"]) >= 2.0: 
     69                raise RuntimeError("SASView only supports SES version 1") 
    8770 
    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 
     71            if "SpinEchoLength_unit" not in self.params: 
     72                raise RuntimeError("SpinEchoLength has no units") 
     73            if "Wavelength_unit" not in self.params: 
     74                raise RuntimeError("Wavelength has no units") 
     75            if params["SpinEchoLength_unit"] != params["Wavelength_unit"]: 
     76                raise RuntimeError("The spin echo data has rudely used " 
     77                                   "different units for the spin echo length " 
     78                                   "and the wavelength.  While sasview could " 
     79                                   "handle this instance, it is a violation " 
     80                                   "of the file format and will not be " 
     81                                   "handled by other software.") 
    10482 
    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])) 
     83            headers = input_f.readline().split() 
    12884 
    129                 x,y,lam,dy,dx,dlam = [ 
    130                    numpy.asarray(v, 'double') 
    131                    for v in (x,y,lam,dy,dx,dlam) 
    132                 ] 
     85            self._insist_header(headers, "SpinEchoLength") 
     86            self._insist_header(headers, "Depolarisation") 
     87            self._insist_header(headers, "Depolarisation_error") 
     88            self._insist_header(headers, "Wavelength") 
    13389 
    134                 input_f.close() 
     90            data = np.loadtxt(input_f) 
    13591 
    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 
     92            if data.shape[1] != len(headers): 
     93                raise RuntimeError( 
     94                    "File has {} headers, but {} columns".format( 
     95                        len(headers), 
     96                        data.shape[1])) 
    14697 
    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 
     98            if not data.size: 
     99                raise RuntimeError("{} is empty".format(path)) 
     100            x = data[:, headers.index("SpinEchoLength")] 
     101            if "SpinEchoLength_error" in headers: 
     102                dx = data[:, headers.index("SpinEchoLength_error")] 
     103            else: 
     104                dx = x * 0.05 
     105            lam = data[:, headers.index("Wavelength")] 
     106            if "Wavelength_error" in headers: 
     107                dlam = data[:, headers.index("Wavelength_error")] 
     108            else: 
     109                dlam = lam * 0.05 
     110            y = data[:, headers.index("Depolarisation")] 
     111            dy = data[:, headers.index("Depolarisation_error")] 
    158112 
    159                 if len(output.x) < 1: 
    160                     raise RuntimeError, "%s is empty" % path 
    161                 return output 
     113            lam_unit = self._unit_fetch("Wavelength") 
     114            x, x_unit = self._unit_conversion(x, "A", 
     115                                              self._unit_fetch( 
     116                                                  "SpinEchoLength")) 
     117            dx, dx_unit = self._unit_conversion( 
     118                dx, lam_unit, 
     119                self._unit_fetch("SpinEchoLength")) 
     120            dlam, dlam_unit = self._unit_conversion( 
     121                dlam, lam_unit, 
     122                self._unit_fetch("Wavelength")) 
     123            y_unit = self._unit_fetch("Depolarisation") 
    162124 
    163         else: 
    164             raise RuntimeError, "%s is not a file" % path 
    165         return None 
     125            output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, 
     126                            isSesans=True) 
    166127 
    167     def _unit_conversion(self, value, value_unit, default_unit): 
    168         if has_converter == True and value_unit != default_unit: 
    169             data_conv_q = Converter(value_unit) 
    170             value = data_conv_q(value, units=default_unit) 
     128            output.y_unit = y_unit 
     129            output.x_unit = x_unit 
     130            output.source.wavelength_unit = lam_unit 
     131            output.source.wavelength = lam 
     132            self.filename = output.filename = basename 
     133            output.xaxis(r"\rm{z}", x_unit) 
     134            # Adjust label to ln P/(lam^2 t), remove lam column refs 
     135            output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit) 
     136            # Store loading process information 
     137            output.meta_data['loader'] = self.type_name 
     138            output.sample.name = params["Sample"] 
     139            output.sample.ID = params["DataFileTitle"] 
     140            output.sample.thickness = self._unit_conversion( 
     141                float(params["Thickness"]), "cm", 
     142                self._unit_fetch("Thickness"))[0] 
     143 
     144            output.sample.zacceptance = ( 
     145                float(params["Theta_zmax"]), 
     146                self._unit_fetch("Theta_zmax")) 
     147 
     148            output.sample.yacceptance = ( 
     149                float(params["Theta_ymax"]), 
     150                self._unit_fetch("Theta_ymax")) 
     151            return output 
     152 
     153    @staticmethod 
     154    def _insist_header(headers, name): 
     155        if name not in headers: 
     156            raise RuntimeError( 
     157                "Missing {} column in spin echo data".format(name)) 
     158 
     159    @staticmethod 
     160    def _unit_conversion(value, value_unit, default_unit): 
     161        """ 
     162        Performs unit conversion on a measurement. 
     163 
     164        :param value: The magnitude of the measurement 
     165        :param value_unit: a string containing the final desired unit 
     166        :param default_unit: string with the units of the original measurement 
     167        :return: The magnitude of the measurement in the new units 
     168        """ 
     169        # (float, string, string) -> float 
     170        if has_converter and value_unit != default_unit: 
     171            data_conv_q = Converter(default_unit) 
     172            value = data_conv_q(value, units=value_unit) 
    171173            new_unit = default_unit 
    172174        else: 
    173175            new_unit = value_unit 
    174176        return value, new_unit 
     177 
     178    def _unit_fetch(self, unit): 
     179        return self.params[unit+"_unit"] 

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

    rb699768 r959eb01  
    1313import logging 
    1414import os 
    15 import numpy 
     15import numpy as np 
    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    """ 
    … …  
    5658 
    5759        # Initiazed the output data object 
    58         output.data = numpy.zeros([im.size[0], im.size[1]]) 
    59         output.err_data = numpy.zeros([im.size[0], im.size[1]]) 
    60         output.mask = numpy.ones([im.size[0], im.size[1]], dtype=bool) 
     60        output.data = np.zeros([im.size[0], im.size[1]]) 
     61        output.err_data = np.zeros([im.size[0], im.size[1]]) 
     62        output.mask = np.ones([im.size[0], im.size[1]], dtype=bool) 
    6163         
    6264        # Initialize 
    … …  
    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             
    … …  
    9496        output.x_bins = x_vals 
    9597        output.y_bins = y_vals 
    96         output.qx_data = numpy.array(x_vals) 
    97         output.qy_data = numpy.array(y_vals) 
     98        output.qx_data = np.array(x_vals) 
     99        output.qy_data = np.array(y_vals) 
    98100        output.xmin = 0 
    99101        output.xmax = im.size[0] - 1 

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

    r527a190 r6a455cd3  
    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 
    … …  
    241243        :param name: The name of the element to be created 
    242244        """ 
    243         if attrib == None: 
     245        if attrib is None: 
    244246            attrib = {} 
    245247        return etree.Element(name, attrib, nsmap) 
    … …  
    300302        """ 
    301303        text = str(text) 
    302         if attrib == None: 
     304        if attrib is None: 
    303305            attrib = {} 
    304306        elem = E(elementname, attrib, text) 

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

    rc94280c r7c24685  
    126126 
    127127            if isinstance(value, h5py.Group): 
     128                parent_class = class_name 
    128129                self.parent_class = class_name 
    129130                parent_list.append(key) 
    … …  
    136137                # Recursion step to access data within the group 
    137138                self.read_children(value, parent_list) 
     139                self.parent_class = parent_class 
    138140                self.add_intermediate() 
    139141                parent_list.remove(key) 
Note: See TracChangeset for help on using the changeset viewer.