Changeset 36d69e1 in sasview


Ignore:
Timestamp:
Mar 23, 2017 9:38:25 PM (8 years ago)
Author:
andyfaff
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
7b15990
Parents:
b2ff1b2
git-author:
Andrew Nelson <andyfaff@…> (03/22/17 00:50:25)
git-committer:
Andrew Nelson <andyfaff@…> (03/23/17 21:38:25)
Message:

MAINT: refactor IgorReader?.py

Files:
3 edited

Legend:

Unmodified
Added
Removed

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

    rb2b36932 r36d69e1  
    8080 
    8181    """ 
    82     if data2d.data == None or data2d.x_bins == None or data2d.y_bins == None: 
     82    if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None: 
    8383        raise ValueError, "Can't convert this data: data=None..." 
    8484    new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
    … …  
    9090    qy_data = new_y.flatten() 
    9191    q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
    92     if data2d.err_data == None or numpy.any(data2d.err_data <= 0): 
     92    if data2d.err_data is None or numpy.any(data2d.err_data <= 0): 
    9393        new_err_data = numpy.sqrt(numpy.abs(new_data)) 
    9494    else: 

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

    rb699768 r36d69e1  
    1313############################################################################# 
    1414import os 
    15 import numpy 
    16 import math 
    17 #import logging 
     15 
    1816from sas.sascalc.dataloader.data_info import Data2D 
    1917from sas.sascalc.dataloader.data_info import Detector 
    2018from sas.sascalc.dataloader.manipulations import reader2D_converter 
     19import numpy as np 
    2120 
    2221# Look for unit converter 
    … …  
    4039        """ Read file """ 
    4140        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 
     41            raise ValueError("Specified file %s is not a regular " 
     42                             "file" % filename) 
     43         
    5044        output = Data2D() 
     45 
    5146        output.filename = os.path.basename(filename) 
    5247        detector = Detector() 
    53         if len(output.detector) > 0: 
    54             print str(output.detector[0]) 
     48        if len(output.detector): 
     49            print(str(output.detector[0])) 
    5550        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': 
     51 
     52        data_conv_q = data_conv_i = None 
     53         
     54        if has_converter and output.Q_unit != '1/A': 
    8355            data_conv_q = Converter('1/A') 
    8456            # Test it 
    8557            data_conv_q(1.0, output.Q_unit) 
    8658             
    87         if has_converter == True and output.I_unit != '1/cm': 
     59        if has_converter and output.I_unit != '1/cm': 
    8860            data_conv_i = Converter('1/cm') 
    8961            # Test it 
    9062            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                    
     63 
     64        data_row = 0 
     65        wavelength = distance = center_x = center_y = None 
     66        dataStarted = isInfo = isCenter = False 
     67 
     68        with open(filename, 'r') as f: 
     69            for line in f: 
     70                data_row += 1 
     71                # Find setup info line 
     72                if isInfo: 
     73                    isInfo = False 
     74                    line_toks = line.split() 
     75                    # Wavelength in Angstrom 
     76                    try: 
     77                        wavelength = float(line_toks[1]) 
     78                    except ValueError: 
     79                        msg = "IgorReader: can't read this file, missing wavelength" 
     80                        raise ValueError(msg) 
     81                    # Distance in meters 
     82                    try: 
     83                        distance = float(line_toks[3]) 
     84                    except ValueError: 
     85                        msg = "IgorReader: can't read this file, missing distance" 
     86                        raise ValueError(msg) 
     87 
     88                    # Distance in meters 
     89                    try: 
     90                        transmission = float(line_toks[4]) 
     91                    except: 
     92                        msg = "IgorReader: can't read this file, " 
     93                        msg += "missing transmission" 
     94                        raise ValueError(msg) 
     95 
     96                if line.count("LAMBDA"): 
     97                    isInfo = True 
     98 
     99                # Find center info line 
     100                if isCenter: 
     101                    isCenter = False 
     102                    line_toks = line.split() 
     103 
     104                    # Center in bin number: Must subtract 1 because 
     105                    # the index starts from 1 
     106                    center_x = float(line_toks[0]) - 1 
     107                    center_y = float(line_toks[1]) - 1 
     108 
     109                if line.count("BCENT"): 
     110                    isCenter = True 
     111 
     112                # Find data start 
     113                if line.count("***"): 
     114                    # now have to continue to blank line 
     115                    dataStarted = True 
     116 
     117                    # Check that we have all the info 
     118                    if (wavelength is None 
     119                            or distance is None 
     120                            or center_x is None 
     121                            or center_y is None): 
     122                        msg = "IgorReader:Missing information in data file" 
     123                        raise ValueError(msg) 
     124 
     125                if dataStarted: 
     126                    if len(line.rstrip()): 
     127                        continue 
     128                    else: 
     129                        break 
     130 
     131        # The data is loaded in row major order (last index changing most 
     132        # rapidly). However, the original data is in column major order (first 
     133        # index changing most rapidly). The swap to column major order is done 
     134        # in reader2D_converter at the end of this method. 
     135        data = np.loadtxt(filename, skiprows=data_row) 
     136        size_x = size_y = int(np.rint(np.sqrt(data.size))) 
     137        output.data = np.reshape(data, (size_x, size_y)) 
     138        output.err_data = np.zeros_like(output.data) 
     139 
     140        # Det 640 x 640 mm 
     141        # Q = 4 * pi/lambda * sin(theta/2) 
     142        # Bin size is 0.5 cm 
     143        # Removed +1 from theta = (i_x - center_x + 1)*0.5 / distance 
     144        # / 100.0 and 
     145        # Removed +1 from theta = (i_y - center_y + 1)*0.5 / 
     146        # distance / 100.0 
     147        # ToDo: Need  complete check if the following 
     148        # convert process is consistent with fitting.py. 
     149 
     150        # calculate qx, qy bin centers of each pixel in the image 
     151        theta = (np.arange(size_x) - center_x) * 0.5 / distance / 100. 
     152        qx = 4 * np.pi / wavelength * np.sin(theta/2) 
     153 
     154        theta = (np.arange(size_y) - center_y) * 0.5 / distance / 100. 
     155        qy = 4 * np.pi / wavelength * np.sin(theta/2) 
     156 
     157        if has_converter and output.Q_unit != '1/A': 
     158            qx = data_conv_q(qx, units=output.Q_unit) 
     159            qy = data_conv_q(qx, units=output.Q_unit) 
     160 
     161        xmax = np.max(qx) 
     162        xmin = np.min(qx) 
     163        ymax = np.max(qy) 
     164        ymin = np.min(qy) 
     165 
     166        # calculate edge offset in q. 
    234167        theta = 0.25 / distance / 100.0 
    235         xstep = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
     168        xstep = 4.0 * np.pi / wavelength * np.sin(theta / 2.0) 
    236169         
    237170        theta = 0.25 / distance / 100.0 
    238         ystep = 4.0 * math.pi/ wavelength * math.sin(theta / 2.0) 
     171        ystep = 4.0 * np.pi/ wavelength * np.sin(theta / 2.0) 
    239172         
    240173        # Store all data ###################################### 
    241174        # Store wavelength 
    242         if has_converter == True and output.source.wavelength_unit != 'A': 
     175        if has_converter and output.source.wavelength_unit != 'A': 
    243176            conv = Converter('A') 
    244177            wavelength = conv(wavelength, units=output.source.wavelength_unit) 
    … …  
    246179 
    247180        # Store distance 
    248         if has_converter == True and detector.distance_unit != 'm': 
     181        if has_converter and detector.distance_unit != 'm': 
    249182            conv = Converter('m') 
    250183            distance = conv(distance, units=detector.distance_unit) 
    … …  
    254187        output.sample.transmission = transmission 
    255188         
    256         # Store pixel size 
     189        # Store pixel size (mm) 
    257190        pixel = 5.0 
    258         if has_converter == True and detector.pixel_size_unit != 'mm': 
     191        if has_converter and detector.pixel_size_unit != 'mm': 
    259192            conv = Converter('mm') 
    260193            pixel = conv(pixel, units=detector.pixel_size_unit) 
    … …  
    267200         
    268201        # 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': 
     202        xmin -= xstep / 2.0 
     203        xmax += xstep / 2.0 
     204        ymin -= ystep / 2.0 
     205        ymax += ystep / 2.0 
     206        if has_converter and output.Q_unit != '1/A': 
    274207            xmin = data_conv_q(xmin, units=output.Q_unit) 
    275208            xmax = data_conv_q(xmax, units=output.Q_unit) 
    … …  
    282215         
    283216        # Store x and y axis bin centers 
    284         output.x_bins = x 
    285         output.y_bins = y 
     217        output.x_bins = qx.tolist() 
     218        output.y_bins = qy.tolist() 
    286219         
    287220        # Units 

  • test/sasdataloader/test/utest_abs_reader.py

    r5f26aa4 r36d69e1  
    44 
    55import unittest 
    6 import numpy, math 
    7 from sas.sascalc.dataloader.loader import  Loader 
     6import math 
     7import numpy as np 
     8from sas.sascalc.dataloader.loader import Loader 
     9from sas.sascalc.dataloader.readers.IgorReader import Reader as IgorReader 
    810from sas.sascalc.dataloader.data_info import Data1D 
    911  
    … …  
    8688     
    8789    def setUp(self): 
    88         self.data = Loader().load("MAR07232_rest.ASC") 
    89          
     90        # the IgorReader should be able to read this filetype 
     91        # if it can't, stop here. 
     92        reader = IgorReader() 
     93        self.data = reader.read("MAR07232_rest.ASC") 
     94 
    9095    def test_igor_checkdata(self): 
    9196        """ 
    … …  
    108113         
    109114        self.assertEqual(self.data.detector[0].beam_center_unit, 'mm') 
    110         center_x = (68.76-1)*5.0 
    111         center_y = (62.47-1)*5.0 
     115        center_x = (68.76 - 1)*5.0 
     116        center_y = (62.47 - 1)*5.0 
    112117        self.assertEqual(self.data.detector[0].beam_center.x, center_x) 
    113118        self.assertEqual(self.data.detector[0].beam_center.y, center_y) 
    114119         
    115120        self.assertEqual(self.data.I_unit, '1/cm') 
    116         self.assertEqual(self.data.data[0], 0.279783) 
    117         self.assertEqual(self.data.data[1], 0.28951) 
    118         self.assertEqual(self.data.data[2], 0.167634) 
    119          
     121        # 3 points should be suffcient to check that the data is in column 
     122        # major order. 
     123        np.testing.assert_almost_equal(self.data.data[0:3], 
     124                                       [0.279783, 0.28951, 0.167634]) 
     125        np.testing.assert_almost_equal(self.data.qx_data[0:3], 
     126                                       [-0.01849072, -0.01821785, -0.01794498]) 
     127        np.testing.assert_almost_equal(self.data.qy_data[0:3], 
     128                                       [-0.01677435, -0.01677435, -0.01677435]) 
     129 
     130    def test_generic_loader(self): 
     131        # the generic loader should direct the file to IgorReader as well 
     132        data = Loader().load("MAR07232_rest.ASC") 
     133        self.assertEqual(data.meta_data['loader'], "IGOR 2D") 
     134 
     135 
    120136class danse_reader(unittest.TestCase): 
    121137     
    … …  
    313329        from sas.sascalc.dataloader.readers.cansas_reader import Reader 
    314330        r = Reader() 
    315         x = numpy.ones(5) 
    316         y = numpy.ones(5) 
    317         dy = numpy.ones(5) 
     331        x = np.ones(5) 
     332        y = np.ones(5) 
     333        dy = np.ones(5) 
    318334         
    319335        filename = "write_test.xml" 
Note: See TracChangeset for help on using the changeset viewer.