source: sasview/DataLoader/readers/danse_reader.py @ b2c6d23

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since b2c6d23 was 4fe4394, checked in by Mathieu Doucet <doucetm@…>, 16 years ago

implemented smearer selection
  • Property mode set to 100644
File size: 10.0 KB
Line 
1"""
2    DANSE/SANS file reader
3"""
4
5"""
6This software was developed by the University of Tennessee as part of the
7Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
8project funded by the US National Science Foundation.
9
10If you use DANSE applications to do scientific research that leads to
11publication, we ask that you acknowledge the use of the software with the
12following sentence:
13
14"This work benefited from DANSE software developed under NSF award DMR-0520547."
15
16copyright 2008, University of Tennessee
17"""
18
19import math
20import os
21import copy
22import numpy
23import logging
24from DataLoader.data_info import Data2D, Detector
25
26# Look for unit converter
27has_converter = True
28try:
29    from data_util.nxsunit import Converter
30except:
31    has_converter = False
32
33class Reader:
34    """
35        Example data manipulation
36    """
37    ## File type
38    type = ["DANSE files (*.sans)|*.sans"]
39    ## Extension
40    ext  = ['.sans', '.SANS']   
41       
42    def read(self, filename=None):
43        """
44            Open and read the data in a file
45            @param file: path of the file
46        """
47       
48        read_it = False
49        for item in self.ext:
50            if filename.lower().find(item)>=0:
51                read_it = True
52               
53        if read_it:
54            try:
55                 datafile = open(filename, 'r')
56            except :
57                raise  RuntimeError,"danse_reader cannot open %s"%(filename)
58           
59           
60            # defaults
61            # wavelength in Angstrom
62            wavelength = 10.0
63            # Distance in meter
64            distance   = 11.0
65            # Pixel number of center in x
66            center_x   = 65
67            # Pixel number of center in y
68            center_y   = 65
69            # Pixel size [mm]
70            pixel      = 5.0
71            # Size in x, in pixels
72            size_x     = 128
73            # Size in y, in pixels
74            size_y     = 128
75            # Format version
76            fversion   = 1.0
77           
78            output = Data2D()
79            output.filename = os.path.basename(filename)
80            detector = Detector()
81            output.detector.append(detector)
82           
83            output.data = numpy.zeros([size_x,size_y])
84            output.err_data = numpy.zeros([size_x,size_y])
85           
86            data_conv_q = None
87            data_conv_i = None
88           
89            if has_converter == True and output.Q_unit != '1/A':
90                data_conv_q = Converter('1/A')
91                # Test it
92                data_conv_q(1.0, output.Q_unit)
93               
94            if has_converter == True and output.I_unit != '1/cm':
95                data_conv_i = Converter('1/cm')
96                # Test it
97                data_conv_i(1.0, output.I_unit)           
98       
99            read_on = True
100            while read_on:
101                line = datafile.readline()
102                if line.find("DATA:")>=0:
103                    read_on = False
104                    break
105                toks = line.split(':')
106                if toks[0]=="FORMATVERSION":
107                    fversion = float(toks[1])
108                if toks[0]=="WAVELENGTH":   
109                    wavelength = float(toks[1])               
110                elif toks[0]=="DISTANCE":
111                    distance = float(toks[1])
112                elif toks[0]=="CENTER_X":
113                    center_x = float(toks[1])
114                elif toks[0]=="CENTER_Y":
115                    center_y = float(toks[1])
116                elif toks[0]=="PIXELSIZE":
117                    pixel = float(toks[1])
118                elif toks[0]=="SIZE_X":
119                    size_x = int(toks[1])
120                elif toks[0]=="SIZE_Y":
121                    size_y = int(toks[1])
122           
123            # Read the data
124            data = []
125            error = []
126            if fversion==1.0:
127                data_str = datafile.readline()
128                data = data_str.split(' ')
129            else:
130                read_on = True
131                while read_on:
132                    data_str = datafile.readline()
133                    if len(data_str)==0:
134                        read_on = False
135                    else:
136                        toks = data_str.split()
137                        try:
138                            val = float(toks[0])
139                            err = float(toks[1])
140                            if data_conv_i is not None:
141                                val = data_conv_i(val, units=output.y_unit)
142                                err = data_conv_i(err, units=output.y_unit)
143                            data.append(val)
144                            error.append(err)
145                        except:
146                            logging.info("Skipping line:%s,%s" %( data_str,sys.exc_value))
147           
148            # Initialize
149            x_vals = []
150            y_vals = [] 
151            ymin = None
152            ymax = None
153            xmin = None
154            xmax = None
155           
156            # Qx and Qy vectors
157            theta = pixel / distance / 100.0
158            stepq = 4.0*math.pi/wavelength * math.sin(theta/2.0) 
159            for i_x in range(size_x):
160                theta = (i_x-center_x+1)*pixel / distance / 100.0
161                qx = 4.0*math.pi/wavelength * math.sin(theta/2.0)
162               
163                if has_converter == True and output.Q_unit != '1/A':
164                    qx = data_conv_q(qx, units=output.Q_unit)
165               
166                x_vals.append(qx)
167                if xmin==None or qx<xmin:
168                    xmin = qx
169                if xmax==None or qx>xmax:
170                    xmax = qx
171           
172            ymin = None
173            ymax = None
174            for i_y in range(size_y):
175                theta = (i_y-center_y+1)*pixel / distance / 100.0
176                qy = 4.0*math.pi/wavelength * math.sin(theta/2.0)
177               
178                if has_converter == True and output.Q_unit != '1/A':
179                    qy = data_conv_q(qy, units=output.Q_unit)
180               
181                y_vals.append(qy)
182                if ymin==None or qy<ymin:
183                    ymin = qy
184                if ymax==None or qy>ymax:
185                    ymax = qy
186           
187            # Store the data in the 2D array
188            itot = 0
189            i_x  = 0
190            i_y  = -1
191           
192            for i_pt in range(len(data)):
193                try:
194                    value = float(data[i_pt])
195                except:
196                    # For version 1.0, the data were still
197                    # stored as strings at this point.
198                    logging.info("Skipping entry (v1.0):%s,%s" %(str(data[i_pt]), sys.exc_value))
199               
200                # Get bin number
201                if math.fmod(i_pt, size_x)==0:
202                    i_x = 0
203                    i_y += 1
204                else:
205                    i_x += 1
206                   
207                output.data[i_y][i_x] = value       
208                #output.data[size_y-1-i_y][i_x] = value
209                if fversion>1.0:
210                    output.err_data[i_y][i_x] = error[i_pt]
211                    #output.err_data[size_y-1-i_y][i_x] = error[i_pt]
212               
213               
214            # Store all data ######################################
215            # Store wavelength
216            if has_converter==True and output.source.wavelength_unit != 'A':
217                conv = Converter('A')
218                wavelength = conv(wavelength, units=output.source.wavelength_unit)
219            output.source.wavelength = wavelength
220               
221            # Store distance
222            if has_converter==True and detector.distance_unit != 'm':
223                conv = Converter('m')
224                distance = conv(distance, units=detector.distance_unit)
225            detector.distance = distance
226           
227            # Store pixel size
228            if has_converter==True and detector.pixel_size_unit != 'mm':
229                conv = Converter('mm')
230                pixel = conv(pixel, units=detector.pixel_size_unit)
231            detector.pixel_size.x = pixel
232            detector.pixel_size.y = pixel
233
234            # Store beam center in distance units
235            detector.beam_center.x = center_x*pixel
236            detector.beam_center.y = center_y*pixel
237           
238            # Store limits of the image (2D array)
239            xmin    =xmin-stepq/2.0
240            xmax    =xmax+stepq/2.0
241            ymin    =ymin-stepq/2.0
242            ymax    =ymax+stepq/2.0
243           
244            if has_converter == True and output.Q_unit != '1/A':
245                xmin = data_conv_q(xmin, units=output.Q_unit)
246                xmax = data_conv_q(xmax, units=output.Q_unit)
247                ymin = data_conv_q(ymin, units=output.Q_unit)
248                ymax = data_conv_q(ymax, units=output.Q_unit)
249            output.xmin = xmin
250            output.xmax = xmax
251            output.ymin = ymin
252            output.ymax = ymax
253           
254            # Store x and y axis bin centers
255            output.x_bins     = x_vals
256            output.y_bins     = y_vals
257           
258            # Units
259            if data_conv_q is not None:
260                output.xaxis("\\rm{Q}", output.Q_unit)
261                output.yaxis("\\rm{Q}", output.Q_unit)
262            else:
263                output.xaxis("\\rm{Q}", 'A^{-1}')
264                output.yaxis("\\rm{Q}", 'A^{-1}')
265               
266            if data_conv_i is not None:
267                output.zaxis("\\{I(Q)}", output.I_unit)
268            else:
269                output.zaxis("\\rm{I(Q)}","cm^{-1}")
270           
271            if not fversion>=1.0:
272                raise ValueError,"Danse_reader can't read this file %s"%filename
273            else:
274                logging.info("Danse_reader Reading %s \n"%filename)
275                return output
276       
277        return None
278
279if __name__ == "__main__": 
280    reader = Reader()
281    print reader.read("../test/MP_New.sans")
282   
Note: See TracBrowser for help on using the repository browser.