source: sasview/test/sasdataloader/test/utest_abs_reader.py @ 5a8cdbb

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.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 5a8cdbb was 5a8cdbb, checked in by lewis, 7 years ago

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