source: sasview/test/sasdataloader/test/utest_cansas.py @ 1fc50fb2

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

Unit test to be sure written file exists before trying to open it.

  • 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        reader_generic = Loader()
114        dataloader = reader_generic.load(self.isis_1_1)
115        reader_cansas = Reader()
116        cansasreader = reader_cansas.read(self.isis_1_1)
117        for i in range(len(dataloader)):
118            self._check_data(dataloader[i])
119            self._check_data_1_1(dataloader[i])
120            self._check_data(cansasreader[i])
121            self._check_data_1_1(cansasreader[i])
122            reader_generic.save(self.write_1_1_filename, dataloader[i], None)
123            reader2 = Loader()
124            self.assertTrue(os.path.isfile(self.write_1_1_filename))
125            return_data = reader2.load(self.write_1_1_filename)
126            written_data = return_data[0]
127            self._check_data(written_data)
128        if os.path.isfile(self.write_1_1_filename):
129            os.remove(self.write_1_1_filename)
130
131    def test_double_trans_spectra(self):
132        xmlreader = XMLreader(self.isis_1_1_doubletrans, self.schema_1_1)
133        self.assertTrue(xmlreader.validate_xml())
134        reader = Loader()
135        data = reader.load(self.isis_1_1_doubletrans)
136        for item in data:
137            self._check_data(item)
138
139    def test_entry_name_recurse(self):
140        test_values = [1,2,3,4,5,6]
141        base_key = "key"
142        d = {}
143        for value in test_values:
144            new_key = self.get_number_of_entries(d, base_key, i = 0)
145            d[new_key] = value
146        self.assertTrue(len(d) == 6)
147
148    def test_load_cansas_file(self):
149        reader1 = XMLreader(self.xml_valid, self.schema_1_0)
150        self.assertTrue(reader1.validate_xml())
151        reader2 = XMLreader(self.xml_invalid, self.schema_1_0)
152        self.assertFalse(reader2.validate_xml())
153        reader3 = XMLreader(self.xml_valid, self.schema_1_1)
154        self.assertFalse(reader3.validate_xml())
155        reader4 = XMLreader(self.xml_invalid, self.schema_1_1)
156        self.assertFalse(reader4.validate_xml())
157        reader5 = XMLreader(self.isis_1_0, self.schema_1_0)
158        self.assertTrue(reader5.validate_xml())
159        reader6 = XMLreader(self.isis_1_1, self.schema_1_1)
160        self.assertTrue(reader6.validate_xml())
161        reader7 = XMLreader(self.isis_1_1, self.schema_1_0)
162        self.assertFalse(reader7.validate_xml())
163
164    def test_invalid_cansas(self):
165        list = self.loader.load(self.cansas1d_notitle)
166        data = list[0]
167        self.assertTrue(data.x.size == 2)
168        self.assertTrue(len(data.meta_data) == 2)
169        self.assertTrue(len(data.errors) == 1)
170        self.assertTrue(data.detector[0].distance_unit == "mm")
171        self.assertTrue(data.detector[0].name == "fictional hybrid")
172        self.assertTrue(data.detector[0].distance == 4150)
173
174    def test_old_cansas_files(self):
175        reader1 = XMLreader(self.cansas1d, self.schema_1_0)
176        self.assertTrue(reader1.validate_xml())
177        file_loader = Loader()
178        file_loader.load(self.cansas1d)
179        reader2 = XMLreader(self.cansas1d_units, self.schema_1_0)
180        self.assertTrue(reader2.validate_xml())
181        reader3 = XMLreader(self.cansas1d_badunits, self.schema_1_0)
182        self.assertTrue(reader3.validate_xml())
183        reader4 = XMLreader(self.cansas1d_slit, self.schema_1_0)
184        self.assertTrue(reader4.validate_xml())
185
186    def test_save_cansas_v1_0(self):
187        xmlreader = XMLreader(self.isis_1_0, self.schema_1_0)
188        valid = xmlreader.validate_xml()
189        self.assertTrue(valid)
190        reader_generic = Loader()
191        dataloader = reader_generic.load(self.isis_1_0)
192        reader_cansas = Reader()
193        cansasreader = reader_cansas.read(self.isis_1_0)
194        for i in range(len(dataloader)):
195            self._check_data(dataloader[i])
196            self._check_data(cansasreader[i])
197            reader_generic.save(self.write_1_0_filename, dataloader[i], None)
198            reader2 = Reader()
199            self.assertTrue(os.path.isfile(self.write_1_0_filename))
200            return_data = reader2.read(self.write_1_0_filename)
201            written_data = return_data[0]
202            XMLreader(self.write_1_0_filename, self.schema_1_0)
203            valid = xmlreader.validate_xml()
204            self.assertTrue(valid)
205            self._check_data(written_data)
206        if os.path.isfile(self.write_1_0_filename):
207            os.remove(self.write_1_0_filename)
208
209    def test_processing_instructions(self):
210        reader = XMLreader(self.isis_1_1, self.schema_1_1)
211        valid = reader.validate_xml()
212        if valid:
213            # find the processing instructions and make into a dictionary
214            dic = self.get_processing_instructions(reader)
215            self.assertTrue(dic == {'xml-stylesheet': \
216                                    'type="text/xsl" href="cansas1d.xsl" '})
217
218            xml = "<test><a><b><c></c></b></a></test>"
219            xmldoc = minidom.parseString(xml)
220
221            # take the processing instructions and put them back in
222            xmldoc = self.set_processing_instructions(xmldoc, dic)
223            xmldoc.toprettyxml()
224
225    def set_processing_instructions(self, minidom_object, dic):
226        xmlroot = minidom_object.firstChild
227        for item in dic:
228            pi = minidom_object.createProcessingInstruction(item, dic[item])
229            minidom_object.insertBefore(pi, xmlroot)
230        return minidom_object
231
232    def get_processing_instructions(self, xml_reader_object):
233        dict = {}
234        pi = xml_reader_object.xmlroot.getprevious()
235        i = 0
236        while pi is not None:
237            attr = {}
238            pi_name = ""
239            pi_string = etree.tostring(pi)
240            if isinstance(pi_string, str):
241                pi_string = pi_string.replace("<?", "").replace("?>", "")
242                split = pi_string.split(" ", 1)
243                pi_name = split[0]
244                attr = split[1]
245            dict[pi_name] = attr
246            pi = pi.getprevious()
247        return dict
248
249
250class cansas_reader_hdf5(unittest.TestCase):
251
252    def setUp(self):
253        self.loader = Loader()
254        self.datafile_basic = "simpleexamplefile.h5"
255        self.datafile_multiplesasentry = "cansas_1Dand2D_samedatafile.h5"
256        self.datafile_multiplesasdata = "cansas_1Dand2D_samesasentry.h5"
257        self.datafile_multiplesasdata_multiplesasentry = "cansas_1Dand2D_multiplesasentry_multiplesasdata.h5"
258
259    def test_real_data(self):
260        self.data = self.loader.load(self.datafile_basic)
261        self._check_example_data(self.data[0])
262
263    def test_multiple_sasentries(self):
264        self.data = self.loader.load(self.datafile_multiplesasentry)
265        self.assertTrue(len(self.data) == 2)
266        self._check_multiple_data(self.data[0])
267        self._check_multiple_data(self.data[1])
268        self._check_1d_data(self.data[0])
269
270    def _check_multiple_data(self, data):
271        self.assertTrue(data.title == "MH4_5deg_16T_SLOW")
272        self.assertTrue(data.run[0] == '33837')
273        self.assertTrue(len(data.run) == 1)
274        self.assertTrue(data.instrument == "SANS2D")
275        self.assertTrue(data.source.radiation == "Spallation Neutron Source")
276        self.assertTrue(len(data.detector) == 1)
277        self.assertTrue(data.detector[0].name == "rear-detector")
278        self.assertTrue(data.detector[0].distance == 4.385281)
279        self.assertTrue(data.detector[0].distance_unit == 'm')
280        self.assertTrue(len(data.trans_spectrum) == 1)
281
282    def _check_1d_data(self, data):
283        self.assertTrue(isinstance(data, Data1D))
284        self.assertTrue(len(data.x) == 66)
285        self.assertTrue(len(data.x) == len(data.y))
286        self.assertTrue(data.dy[10] == 0.20721350111248701)
287        self.assertTrue(data.y[10] == 24.193889608153476)
288        self.assertTrue(data.x[10] == 0.008981127988654792)
289
290    def _check_2d_data(self, data):
291        self.assertTrue(isinstance(data, Data2D))
292        self.assertTrue(len(data.x) == 66)
293        self.assertTrue(len(data.x) == len(data.y))
294        self.assertTrue(data.dy[10] == 0.20721350111248701)
295        self.assertTrue(data.y[10] == 24.193889608153476)
296        self.assertTrue(data.x[10] == 0.008981127988654792)
297
298    def _check_example_data(self, data):
299        self.assertTrue(data.title == "")
300        self.assertTrue(data.x.size == 100)
301        self.assertTrue(data._xunit == "A^{-1}")
302        self.assertTrue(data._yunit == "cm^{-1}")
303        self.assertTrue(data.y.size == 100)
304        self.assertAlmostEqual(data.y[9], 0.952749011516985)
305        self.assertAlmostEqual(data.x[9], 0.3834415188257777)
306        self.assertAlmostEqual(len(data.meta_data), 0)
307
308
309if __name__ == '__main__':
310    unittest.main()   
Note: See TracBrowser for help on using the repository browser.