source: sasview/test/sasdataloader/test/utest_cansas.py @ 17e257b5

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 17e257b5 was 17e257b5, checked in by krzywon, 3 years ago

Fix the broken unit tests associated with the readers.

  • Property mode set to 100644
File size: 12.6 KB
Line 
1"""
2    Unit tests for the new recursive cansas reader
3"""
4import sas.sascalc.dataloader.readers.cansas_reader as cansas
5from sas.sascalc.dataloader.loader import Loader
6from sas.sascalc.dataloader.data_info import Data1D, Data2D
7from sas.sascalc.dataloader.readers.xml_reader import XMLreader
8from sas.sascalc.dataloader.readers.cansas_reader import Reader
9from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants
10
11import os
12import sys
13import urllib2
14import StringIO
15import pylint as pylint
16import unittest
17import numpy as np
18import logging
19import warnings
20
21from lxml import etree
22from lxml.etree import XMLSyntaxError
23from xml.dom import minidom
24
25logger = logging.getLogger(__name__)
26
27warnings.simplefilter("ignore")
28
29CANSAS_FORMAT = CansasConstants.CANSAS_FORMAT
30CANSAS_NS = CansasConstants.CANSAS_NS
31
32class cansas_reader_xml(unittest.TestCase):
33
34    def setUp(self):
35        self.loader = Loader()
36        self.xml_valid = "cansas_test_modified.xml"
37        self.xml_invalid = "cansas_test.xml"
38        self.cansas1d_badunits = "cansas1d_badunits.xml"
39        self.cansas1d = "cansas1d.xml"
40        self.cansas1d_slit = "cansas1d_slit.xml"
41        self.cansas1d_units = "cansas1d_units.xml"
42        self.cansas1d_notitle = "cansas1d_notitle.xml"
43        self.isis_1_0 = "ISIS_1_0.xml"
44        self.isis_1_1 = "ISIS_1_1.xml"
45        self.isis_1_1_notrans = "ISIS_1_1_notrans.xml"
46        self.isis_1_1_doubletrans = "ISIS_1_1_doubletrans.xml"
47        self.schema_1_0 = "cansas1d_v1_0.xsd"
48        self.schema_1_1 = "cansas1d_v1_1.xsd"
49        self.write_1_0_filename = "isis_1_0_write_test.xml"
50        self.write_1_1_filename = "isis_1_1_write_test.xml"
51
52    def get_number_of_entries(self, dictionary, name, i):
53        if dictionary.get(name) is not None:
54            i += 1
55            name = name.split("_")[0]
56            name += "_{0}".format(i)
57            name = self.get_number_of_entries(dictionary, name, i)
58        return name
59
60    def test_invalid_xml(self):
61        """
62        Should fail gracefully and send a message to logger.info()
63        """
64        invalid = StringIO.StringIO('<a><c></b></a>')
65        self.assertRaises(XMLSyntaxError, lambda: XMLreader(invalid))
66
67    def test_xml_validate(self):
68        string = "<xsd:schema xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">\n"
69        string += "\t<xsd:element name=\"a\" type=\"AType\"/>\n"
70        string += "\t<xsd:complexType name=\"AType\">\n"
71        string += "\t\t<xsd:sequence>\n"
72        string += "\t\t\t<xsd:element name=\"b\" type=\"xsd:string\" />\n"
73        string += "\t\t</xsd:sequence>\n"
74        string += "\t</xsd:complexType>\n"
75        string += "</xsd:schema>"
76        f = StringIO.StringIO(string)
77        xmlschema_doc = etree.parse(f)
78        xmlschema = etree.XMLSchema(xmlschema_doc)
79        valid = etree.parse(StringIO.StringIO('<a><b></b></a>'))
80        invalid = etree.parse(StringIO.StringIO('<a><c></c></a>'))
81        self.assertTrue(xmlschema.validate(valid))
82        self.assertFalse(xmlschema.validate(invalid))
83
84    def test_real_xml(self):
85        reader = XMLreader(self.xml_valid, self.schema_1_0)
86        valid = reader.validate_xml()
87        if valid:
88            self.assertTrue(valid)
89        else:
90            self.assertFalse(valid)
91
92    def _check_data(self, data):
93        self.assertTrue(data.title == "TK49 c10_SANS")
94        self.assertTrue(data.x.size == 138)
95        self.assertTrue(len(data.meta_data) == 3)
96        self.assertTrue(data.detector[0].distance_unit == "mm")
97        self.assertTrue(data.detector[1].distance_unit == "mm")
98        self.assertTrue(data.detector[0].name == "HAB")
99        self.assertTrue(data.detector[1].name == "main-detector-bank")
100        self.assertTrue(data.detector[0].distance == 575.0)
101        self.assertAlmostEqual(data.detector[1].distance, 4145.02)
102        self.assertTrue(data.process[0].name == "Mantid generated CanSAS1D XML")
103        self.assertTrue(data.meta_data["xmlpreprocess"] is not None)
104
105    def _check_data_1_1(self, data):
106        spectrum = data.trans_spectrum[0]
107        self.assertTrue(len(spectrum.wavelength) == 138)
108
109    def test_cansas_xml(self):
110        xmlreader = XMLreader(self.isis_1_1, self.schema_1_1)
111        valid = xmlreader.validate_xml()
112        xmlreader.set_processing_instructions()
113        self.assertTrue(valid)
114        reader_generic = Loader()
115        dataloader = reader_generic.load(self.isis_1_1)
116        reader_cansas = Reader()
117        cansasreader = reader_cansas.read(self.isis_1_1)
118        for i in range(len(dataloader)):
119            self._check_data(dataloader[i])
120            self._check_data_1_1(dataloader[i])
121            self._check_data(cansasreader[i])
122            self._check_data_1_1(cansasreader[i])
123            reader_generic.save(self.write_1_1_filename, dataloader[i], None)
124            reader2 = Loader()
125            self.assertTrue(os.path.isfile(self.write_1_1_filename))
126            return_data = reader2.load(self.write_1_1_filename)
127            written_data = return_data[0]
128            self._check_data(written_data)
129        if os.path.isfile(self.write_1_1_filename):
130            os.remove(self.write_1_1_filename)
131
132    def test_double_trans_spectra(self):
133        xmlreader = XMLreader(self.isis_1_1_doubletrans, self.schema_1_1)
134        self.assertTrue(xmlreader.validate_xml())
135        reader = Loader()
136        data = reader.load(self.isis_1_1_doubletrans)
137        for item in data:
138            self._check_data(item)
139
140    def test_entry_name_recurse(self):
141        test_values = [1,2,3,4,5,6]
142        base_key = "key"
143        d = {}
144        for value in test_values:
145            new_key = self.get_number_of_entries(d, base_key, i = 0)
146            d[new_key] = value
147        self.assertTrue(len(d) == 6)
148
149    def test_load_cansas_file(self):
150        reader1 = XMLreader(self.xml_valid, self.schema_1_0)
151        self.assertTrue(reader1.validate_xml())
152        reader2 = XMLreader(self.xml_invalid, self.schema_1_0)
153        self.assertFalse(reader2.validate_xml())
154        reader3 = XMLreader(self.xml_valid, self.schema_1_1)
155        self.assertFalse(reader3.validate_xml())
156        reader4 = XMLreader(self.xml_invalid, self.schema_1_1)
157        self.assertFalse(reader4.validate_xml())
158        reader5 = XMLreader(self.isis_1_0, self.schema_1_0)
159        self.assertTrue(reader5.validate_xml())
160        reader6 = XMLreader(self.isis_1_1, self.schema_1_1)
161        self.assertTrue(reader6.validate_xml())
162        reader7 = XMLreader(self.isis_1_1, self.schema_1_0)
163        self.assertFalse(reader7.validate_xml())
164
165    def test_invalid_cansas(self):
166        list = self.loader.load(self.cansas1d_notitle)
167        data = list[0]
168        self.assertTrue(data.x.size == 2)
169        self.assertTrue(len(data.meta_data) == 2)
170        self.assertTrue(len(data.errors) == 1)
171        self.assertTrue(data.detector[0].distance_unit == "mm")
172        self.assertTrue(data.detector[0].name == "fictional hybrid")
173        self.assertTrue(data.detector[0].distance == 4150)
174
175    def test_old_cansas_files(self):
176        reader1 = XMLreader(self.cansas1d, self.schema_1_0)
177        self.assertTrue(reader1.validate_xml())
178        file_loader = Loader()
179        file_loader.load(self.cansas1d)
180        reader2 = XMLreader(self.cansas1d_units, self.schema_1_0)
181        self.assertTrue(reader2.validate_xml())
182        reader3 = XMLreader(self.cansas1d_badunits, self.schema_1_0)
183        self.assertTrue(reader3.validate_xml())
184        reader4 = XMLreader(self.cansas1d_slit, self.schema_1_0)
185        self.assertTrue(reader4.validate_xml())
186
187    def test_save_cansas_v1_0(self):
188        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0)
189        valid = xmlreader.validate_xml()
190        self.assertTrue(valid)
191        reader_generic = Loader()
192        dataloader = reader_generic.load(self.isis_1_0)
193        reader_cansas = Reader()
194        cansasreader = reader_cansas.read(self.isis_1_0)
195        for i in range(len(dataloader)):
196            self._check_data(dataloader[i])
197            self._check_data(cansasreader[i])
198            reader_generic.save(self.write_1_0_filename, dataloader[i], None)
199            reader2 = Reader()
200            self.assertTrue(os.path.isfile(self.write_1_0_filename))
201            return_data = reader2.read(self.write_1_0_filename)
202            written_data = return_data[0]
203            XMLreader(self.write_1_0_filename, self.schema_1_0)
204            valid = xmlreader.validate_xml()
205            self.assertTrue(valid)
206            self._check_data(written_data)
207        if os.path.isfile(self.write_1_0_filename):
208            os.remove(self.write_1_0_filename)
209
210    def test_processing_instructions(self):
211        reader = XMLreader(self.isis_1_1, self.schema_1_1)
212        valid = reader.validate_xml()
213        if valid:
214            # find the processing instructions and make into a dictionary
215            dic = self.get_processing_instructions(reader)
216            self.assertTrue(dic == {'xml-stylesheet': \
217                                    'type="text/xsl" href="cansas1d.xsl" '})
218
219            xml = "<test><a><b><c></c></b></a></test>"
220            xmldoc = minidom.parseString(xml)
221
222            # take the processing instructions and put them back in
223            xmldoc = self.set_processing_instructions(xmldoc, dic)
224            xmldoc.toprettyxml()
225
226    def set_processing_instructions(self, minidom_object, dic):
227        xmlroot = minidom_object.firstChild
228        for item in dic:
229            pi = minidom_object.createProcessingInstruction(item, dic[item])
230            minidom_object.insertBefore(pi, xmlroot)
231        return minidom_object
232
233    def get_processing_instructions(self, xml_reader_object):
234        dict = {}
235        pi = xml_reader_object.xmlroot.getprevious()
236        i = 0
237        while pi is not None:
238            attr = {}
239            pi_name = ""
240            pi_string = etree.tostring(pi)
241            if isinstance(pi_string, str):
242                pi_string = pi_string.replace("<?", "").replace("?>", "")
243                split = pi_string.split(" ", 1)
244                pi_name = split[0]
245                attr = split[1]
246            dict[pi_name] = attr
247            pi = pi.getprevious()
248        return dict
249
250
251class cansas_reader_hdf5(unittest.TestCase):
252
253    def setUp(self):
254        self.loader = Loader()
255        self.datafile_basic = "simpleexamplefile.h5"
256        self.datafile_multiplesasentry = "cansas_1Dand2D_samedatafile.h5"
257        self.datafile_multiplesasdata = "cansas_1Dand2D_samesasentry.h5"
258        self.datafile_multiplesasdata_multiplesasentry = "cansas_1Dand2D_multiplesasentry_multiplesasdata.h5"
259
260    def test_real_data(self):
261        self.data = self.loader.load(self.datafile_basic)
262        self._check_example_data(self.data[0])
263
264    def test_multiple_sasentries(self):
265        self.data = self.loader.load(self.datafile_multiplesasentry)
266        self.assertTrue(len(self.data) == 2)
267        self._check_multiple_data(self.data[0])
268        self._check_multiple_data(self.data[1])
269        self._check_1d_data(self.data[0])
270
271    def _check_multiple_data(self, data):
272        self.assertTrue(data.title == "MH4_5deg_16T_SLOW")
273        self.assertTrue(data.run[0] == '33837')
274        self.assertTrue(len(data.run) == 1)
275        self.assertTrue(data.instrument == "SANS2D")
276        self.assertTrue(data.source.radiation == "Spallation Neutron Source")
277        self.assertTrue(len(data.detector) == 1)
278        self.assertTrue(data.detector[0].name == "rear-detector")
279        self.assertTrue(data.detector[0].distance == 4.385281)
280        self.assertTrue(data.detector[0].distance_unit == 'm')
281        self.assertTrue(len(data.trans_spectrum) == 1)
282
283    def _check_1d_data(self, data):
284        self.assertTrue(isinstance(data, Data1D))
285        self.assertTrue(len(data.x) == 66)
286        self.assertTrue(len(data.x) == len(data.y))
287        self.assertTrue(data.dy[10] == 0.20721350111248701)
288        self.assertTrue(data.y[10] == 24.193889608153476)
289        self.assertTrue(data.x[10] == 0.008981127988654792)
290
291    def _check_2d_data(self, data):
292        self.assertTrue(isinstance(data, Data2D))
293        self.assertTrue(len(data.x) == 66)
294        self.assertTrue(len(data.x) == len(data.y))
295        self.assertTrue(data.dy[10] == 0.20721350111248701)
296        self.assertTrue(data.y[10] == 24.193889608153476)
297        self.assertTrue(data.x[10] == 0.008981127988654792)
298
299    def _check_example_data(self, data):
300        self.assertTrue(data.title == "")
301        self.assertTrue(data.x.size == 100)
302        self.assertTrue(data._xunit == "A^{-1}")
303        self.assertTrue(data._yunit == "cm^{-1}")
304        self.assertTrue(data.y.size == 100)
305        self.assertAlmostEqual(data.y[40], 0.952749011516985)
306        self.assertAlmostEqual(data.x[40], 0.3834415188257777)
307        self.assertAlmostEqual(len(data.meta_data), 0)
308
309
310if __name__ == '__main__':
311    unittest.main()   
Note: See TracBrowser for help on using the repository browser.