source: sasview/test/sasdataloader/test/utest_abs_reader.py @ bd5c3b1

magnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249unittest-saveload
Last change on this file since bd5c3b1 was bd5c3b1, checked in by krzywon, 13 months ago

Use q_mean from ABS files to match Igor analysis.

  • Property mode set to 100644
File size: 14.3 KB
Line 
1"""
2    Unit tests for data manipulations
3"""
4from __future__ import print_function
5
6import unittest
7import numpy as np
8from sas.sascalc.dataloader.loader import Loader
9from sas.sascalc.dataloader.readers.abs_reader import Reader as AbsReader
10from sas.sascalc.dataloader.readers.danse_reader import Reader as DANSEReader
11from sas.sascalc.dataloader.readers.cansas_reader import Reader as CANSASReader
12
13from sas.sascalc.dataloader.data_info import Data1D
14
15import os.path
16
17
18def find(filename):
19    return os.path.join(os.path.dirname(__file__), filename)
20
21
22class abs_reader(unittest.TestCase):
23
24    def setUp(self):
25        reader = AbsReader()
26        self.data_list = reader.read(find("jan08002.ABS"))
27        self.data = self.data_list[0]
28
29    def test_abs_checkdata(self):
30        """
31            Check the data content to see whether
32            it matches the specific file we loaded.
33            Check the units too to see whether the
34            Data1D defaults changed. Otherwise the
35            tests won't pass
36        """
37        self.assertEqual(os.path.basename(self.data.filename), "jan08002.ABS")
38        self.assertEqual(self.data.meta_data['loader'], "IGOR 1D")
39
40        self.assertEqual(self.data.source.wavelength_unit, 'A')
41        self.assertEqual(self.data.source.wavelength, 6.0)
42
43        self.assertEqual(self.data.detector[0].distance_unit, 'mm')
44        self.assertEqual(self.data.detector[0].distance, 1000.0)
45
46        self.assertEqual(self.data.sample.transmission, 0.5667)
47
48        self.assertEqual(self.data.detector[0].beam_center_unit, 'mm')
49        center_x = 114.58*5.08
50        center_y = 64.22*5.08
51        self.assertEqual(self.data.detector[0].beam_center.x, center_x)
52        self.assertEqual(self.data.detector[0].beam_center.y, center_y)
53
54        self.assertEqual(self.data.y_unit, 'cm^{-1}')
55        self.assertEqual(self.data.x[0], 0.008082)
56        self.assertEqual(self.data.x[1], 0.0275)
57        self.assertEqual(self.data.x[2], 0.02762)
58        self.assertEqual(self.data.x[126], 0.5828)
59
60        self.assertEqual(self.data.y[0], 0.02198)
61        self.assertEqual(self.data.y[1], 0.02201)
62        self.assertEqual(self.data.y[2], 0.02695)
63        self.assertEqual(self.data.y[126], 0.2958)
64
65        self.assertEqual(self.data.dy[0], 0.002704)
66        self.assertEqual(self.data.dy[1], 0.001643)
67        self.assertEqual(self.data.dy[2], 0.002452)
68        self.assertEqual(self.data.dy[126], 1)
69
70    def test_checkdata2(self):
71        self.assertEqual(self.data.dy[126], 1)
72
73    def test_generic_loader(self):
74        # the generic loader should work as well
75        data = Loader().load(find("jan08002.ABS"))
76        self.assertEqual(data[0].meta_data['loader'], "IGOR 1D")
77
78    def test_usans_negative_dxl(self):
79        data_abs = Loader().load(find("sam14_cor.ABS"))
80        data_cor = Loader().load(find("sam14_cor.cor"))
81        for i in range(0, len(data_abs) - 1):
82            self.assertEquals(data_abs.x[i], data_cor.x[i])
83            self.assertEquals(data_abs.y[i], data_cor.y[i])
84            self.assertEquals(data_abs.dxl[i], data_cor.dxl[i])
85            self.assertEquals(data_abs.dxw[i], data_cor.dxw[i])
86            self.assertTrue(data_abs.dxl > 0)
87
88
89class DanseReaderTests(unittest.TestCase):
90
91    def setUp(self):
92        reader = DANSEReader()
93        self.data_list = reader.read(find("MP_New.sans"))
94        self.data = self.data_list[0]
95
96    def test_checkdata(self):
97        """
98            Check the data content to see whether
99            it matches the specific file we loaded.
100            Check the units too to see whether the
101            Data1D defaults changed. Otherwise the
102            tests won't pass
103        """
104        self.assertEqual(len(self.data_list), 1)
105        self.assertEqual(os.path.basename(self.data.filename), "MP_New.sans")
106        self.assertEqual(self.data.meta_data['loader'], "DANSE")
107
108        self.assertEqual(self.data.source.wavelength_unit, 'A')
109        self.assertEqual(self.data.source.wavelength, 7.5)
110
111        self.assertEqual(self.data.detector[0].distance_unit, 'mm')
112        self.assertAlmostEqual(self.data.detector[0].distance, 5414.99, 3)
113
114        self.assertEqual(self.data.detector[0].beam_center_unit, 'mm')
115        center_x = 68.74*5.0
116        center_y = 64.77*5.0
117        self.assertEqual(self.data.detector[0].beam_center.x, center_x)
118        self.assertEqual(self.data.detector[0].beam_center.y, center_y)
119
120        self.assertEqual(self.data.I_unit, '1/cm')
121        self.assertEqual(self.data.data[0], 1.57831)
122        self.assertEqual(self.data.data[1], 2.70983)
123        self.assertEqual(self.data.data[2], 3.83422)
124
125        self.assertEqual(self.data.err_data[0], 1.37607)
126        self.assertEqual(self.data.err_data[1], 1.77569)
127        self.assertEqual(self.data.err_data[2], 2.06313)
128
129    def test_generic_loader(self):
130        # the generic loader should work as well
131        data = Loader().load(find("MP_New.sans"))
132        self.assertEqual(len(data), 1)
133        self.assertEqual(data[0].meta_data['loader'], "DANSE")
134
135
136class cansas_reader(unittest.TestCase):
137
138    def setUp(self):
139        reader = CANSASReader()
140        self.data_list = reader.read(find("cansas1d.xml"))
141        self.data = self.data_list[0]
142
143    def test_generic_loader(self):
144        # the generic loader should work as well
145        data = Loader().load(find("cansas1d.xml"))
146        self.assertEqual(len(data), 1)
147        self.assertEqual(data[0].meta_data['loader'], "CanSAS XML 1D")
148
149    def test_cansas_checkdata(self):
150        self.assertEqual(os.path.basename(self.data.filename), "cansas1d.xml")
151        self._checkdata()
152
153    def _checkdata(self):
154        """
155            Check the data content to see whether
156            it matches the specific file we loaded.
157            Check the units too to see whether the
158            Data1D defaults changed. Otherwise the
159            tests won't pass
160        """
161        self.assertEqual(len(self.data_list), 1)
162        self.assertEqual(self.data.run[0], "1234")
163        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D")
164
165        # Data
166        self.assertEqual(len(self.data.x), 2)
167        self.assertEqual(self.data.x_unit, 'A^{-1}')
168        self.assertEqual(self.data.y_unit, 'cm^{-1}')
169        self.assertAlmostEqual(self.data.x[0], 0.02, 6)
170        self.assertAlmostEqual(self.data.y[0], 1000, 6)
171        self.assertAlmostEqual(self.data.dx[0], 0.01, 6)
172        self.assertAlmostEqual(self.data.dy[0], 3, 6)
173        self.assertAlmostEqual(self.data.x[1], 0.03, 6)
174        self.assertAlmostEqual(self.data.y[1], 1001.0)
175        self.assertAlmostEqual(self.data.dx[1], 0.02, 6)
176        self.assertAlmostEqual(self.data.dy[1], 4, 6)
177        self.assertEqual(self.data.run_name['1234'], 'run name')
178        self.assertEqual(self.data.title, "Test title")
179
180        # Sample info
181        self.assertEqual(self.data.sample.ID, "SI600-new-long")
182        self.assertEqual(self.data.sample.name, "my sample")
183        self.assertEqual(self.data.sample.thickness_unit, 'mm')
184        self.assertAlmostEqual(self.data.sample.thickness, 1.03)
185
186        self.assertAlmostEqual(self.data.sample.transmission, 0.327)
187
188        self.assertEqual(self.data.sample.temperature_unit, 'C')
189        self.assertEqual(self.data.sample.temperature, 0)
190
191        self.assertEqual(self.data.sample.position_unit, 'mm')
192        self.assertEqual(self.data.sample.position.x, 10)
193        self.assertEqual(self.data.sample.position.y, 0)
194
195        self.assertEqual(self.data.sample.orientation_unit, 'degree')
196        self.assertAlmostEqual(self.data.sample.orientation.x, 22.5, 6)
197        self.assertAlmostEqual(self.data.sample.orientation.y, 0.02, 6)
198
199        self.assertEqual(self.data.sample.details[0], "http://chemtools.chem.soton.ac.uk/projects/blog/blogs.php/bit_id/2720")
200        self.assertEqual(self.data.sample.details[1], "Some text here")
201
202        # Instrument info
203        self.assertEqual(self.data.instrument, "canSAS instrument")
204
205        # Source
206        self.assertEqual(self.data.source.radiation, "neutron")
207
208        self.assertEqual(self.data.source.beam_size_unit, "mm")
209        self.assertEqual(self.data.source.beam_size_name, "bm")
210        self.assertEqual(self.data.source.beam_size.x, 12)
211        self.assertEqual(self.data.source.beam_size.y, 13)
212
213        self.assertEqual(self.data.source.beam_shape, "disc")
214
215        self.assertEqual(self.data.source.wavelength_unit, "A")
216        self.assertEqual(self.data.source.wavelength, 6)
217
218        self.assertEqual(self.data.source.wavelength_max_unit, "nm")
219        self.assertAlmostEqual(self.data.source.wavelength_max, 1.0)
220        self.assertEqual(self.data.source.wavelength_min_unit, "nm")
221        self.assertAlmostEqual(self.data.source.wavelength_min, 0.22)
222        self.assertEqual(self.data.source.wavelength_spread_unit, "percent")
223        self.assertEqual(self.data.source.wavelength_spread, 14.3)
224
225        # Collimation
226        _found1 = False
227        _found2 = False
228        self.assertEqual(self.data.collimation[0].length, 123.)
229        self.assertEqual(self.data.collimation[0].name, 'test coll name')
230
231        for item in self.data.collimation[0].aperture:
232            self.assertEqual(item.size_unit,'mm')
233            self.assertEqual(item.distance_unit,'mm')
234
235            if item.size.x == 50 \
236                and item.distance == 11000.0 \
237                and item.name == 'source' \
238                and item.type == 'radius':
239                _found1 = True
240            elif item.size.x == 1.0 \
241                and item.name == 'sample' \
242                and item.type == 'radius':
243                _found2 = True
244
245        if not _found1 or not _found2:
246            raise RuntimeError("Could not find all data %s %s"
247                               % (_found1, _found2))
248
249        # Detector
250        self.assertEqual(self.data.detector[0].name, "fictional hybrid")
251        self.assertEqual(self.data.detector[0].distance_unit, "mm")
252        self.assertEqual(self.data.detector[0].distance, 4150)
253
254        self.assertEqual(self.data.detector[0].orientation_unit, "degree")
255        self.assertAlmostEqual(self.data.detector[0].orientation.x, 1.0, 6)
256        self.assertEqual(self.data.detector[0].orientation.y, 0.0)
257        self.assertEqual(self.data.detector[0].orientation.z, 0.0)
258
259        self.assertEqual(self.data.detector[0].offset_unit, "m")
260        self.assertEqual(self.data.detector[0].offset.x, .001)
261        self.assertEqual(self.data.detector[0].offset.y, .002)
262        self.assertEqual(self.data.detector[0].offset.z, None)
263
264        self.assertEqual(self.data.detector[0].beam_center_unit, "mm")
265        self.assertEqual(self.data.detector[0].beam_center.x, 322.64)
266        self.assertEqual(self.data.detector[0].beam_center.y, 327.68)
267        self.assertEqual(self.data.detector[0].beam_center.z, None)
268
269        self.assertEqual(self.data.detector[0].pixel_size_unit, "mm")
270        self.assertEqual(self.data.detector[0].pixel_size.x, 5)
271        self.assertEqual(self.data.detector[0].pixel_size.y, 5)
272        self.assertEqual(self.data.detector[0].pixel_size.z, None)
273
274        # Process
275        _found_term1 = False
276        _found_term2 = False
277        for item in self.data.process:
278            self.assertTrue(item.name in ['NCNR-IGOR', 'spol'])
279            self.assertTrue(item.date in ['04-Sep-2007 18:35:02',
280                                          '03-SEP-2006 11:42:47'])
281            for t in item.term:
282                if (t['name'] == "ABS:DSTAND"
283                    and t['unit'] == 'mm'
284                    and float(t['value']) == 1.0):
285                    _found_term2 = True
286                elif (t['name'] == "radialstep"
287                      and t['unit'] == 'mm'
288                      and float(t['value']) == 10.0):
289                    _found_term1 = True
290
291        if not _found_term1 or not _found_term2:
292            raise RuntimeError("Could not find all process terms %s %s"
293                               % (_found_term1, _found_term2))
294
295    def test_writer(self):
296        r = CANSASReader()
297
298        filename = "write_test.xml"
299        r.write(find(filename), self.data)
300        data = Loader().load(find(filename))
301        self.data = data[0]
302        self.assertEqual(len(data), 1)
303        self.assertEqual(self.data.filename, filename)
304        self._checkdata()
305        if os.path.isfile(filename):
306            os.remove(filename)
307
308    def test_units(self):
309        """
310            Check units.
311            Note that not all units are available.
312        """
313        filename = "cansas1d_units.xml"
314        data = CANSASReader().read(find(filename))
315        self.data = data[0]
316        self.assertEqual(len(data), 1)
317        self.assertEqual(self.data.filename, filename)
318        self._checkdata()
319
320    def test_badunits(self):
321        """
322            Check units.
323            Note that not all units are available.
324        """
325        filename = "cansas1d_badunits.xml"
326        data = CANSASReader().read(find(filename))
327        self.data = data[0]
328        self.assertEqual(len(data), 1)
329        self.assertEqual(self.data.filename, filename)
330        # The followed should not have been loaded
331        self.assertAlmostEqual(self.data.sample.thickness, 0.00103)
332        # This one should
333        self.assertAlmostEqual(self.data.sample.transmission, 0.327)
334
335        self.assertEqual(self.data.meta_data['loader'], "CanSAS XML 1D")
336        self.assertEqual(len(self.data.errors), 0)
337
338    def test_slits(self):
339        """
340            Check slit data
341        """
342        filename = "cansas1d_slit.xml"
343        data = CANSASReader().read(find(filename))
344        self.data = data[0]
345        self.assertEqual(len(data), 1)
346        self.assertEqual(len(self.data_list), 1)
347        self.assertEqual(self.data.filename, filename)
348        self.assertEqual(self.data.run[0], "1234")
349
350        # Data
351        self.assertEqual(len(self.data.x), 2)
352        self.assertEqual(self.data.x_unit, 'A^{-1}')
353        self.assertEqual(self.data.y_unit, 'cm^{-1}')
354        self.assertEqual(self.data.x[0], 0.02)
355        self.assertEqual(self.data.y[0], 1000)
356        self.assertEqual(self.data.dxl[0], 0.005)
357        self.assertEqual(self.data.dxw[0], 0.001)
358        self.assertEqual(self.data.dy[0], 3)
359        self.assertEqual(self.data.x[1], 0.03)
360        self.assertAlmostEquals(self.data.y[1], 1001.0)
361        self.assertEqual(self.data.dxl[1], 0.005)
362        self.assertEqual(self.data.dxw[1], 0.001)
363        self.assertEqual(self.data.dy[1], 4)
364        self.assertEqual(self.data.run_name['1234'], 'run name')
365        self.assertEqual(self.data.title, "Test title")
366
367
368if __name__ == '__main__':
369    unittest.main()
Note: See TracBrowser for help on using the repository browser.