source: sasview/test/sasdataloader/test/utest_cansas.py @ 7432acb

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 7432acb was 7432acb, checked in by andyfaff, 7 years ago

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