source: sasview/test/sasdataloader/test/utest_cansas.py @ 717e456

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 717e456 was 17c9436, checked in by krzywon, 7 years ago

Remove all files dynamically genereated during unit testing.

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