1 | """ |
---|
2 | This software was developed by the University of Tennessee as part of the |
---|
3 | Distributed Data Analysis of Neutron Scattering Experiments (DANSE) |
---|
4 | project funded by the US National Science Foundation. |
---|
5 | |
---|
6 | See the license text in license.txt |
---|
7 | |
---|
8 | copyright 2008, University of Tennessee |
---|
9 | """ |
---|
10 | |
---|
11 | #TODO: Unit conversion |
---|
12 | #TODO: missing aperture type: go through all entries and check for additional attributes |
---|
13 | #TODO: check that all vectors are written only if they have at least one non-empty value |
---|
14 | #TODO: multiple SASEntrys |
---|
15 | #TODO: Store error list |
---|
16 | #TODO: convert from pixel to mm for beam center... |
---|
17 | #TODO: Allow for additional meta data for each section |
---|
18 | #TODO: Notes need to be implemented. They can be any XML structure in version 1.0 |
---|
19 | # Process notes have the same problem. |
---|
20 | |
---|
21 | |
---|
22 | import logging |
---|
23 | import numpy |
---|
24 | import os, sys |
---|
25 | from DataLoader.data_info import Data1D, Collimation, Detector, Process, Aperture |
---|
26 | from xml import xpath |
---|
27 | import xml.dom.minidom |
---|
28 | |
---|
29 | |
---|
30 | has_converter = True |
---|
31 | try: |
---|
32 | from data_util.nxsunit import Converter |
---|
33 | except: |
---|
34 | has_converter = False |
---|
35 | |
---|
36 | def write_node(doc, parent, name, value, attr={}): |
---|
37 | """ |
---|
38 | @param doc: document DOM |
---|
39 | @param parent: parent node |
---|
40 | @param name: tag of the element |
---|
41 | @param value: value of the child text node |
---|
42 | @param attr: attribute dictionary |
---|
43 | @return: True if something was appended, otherwise False |
---|
44 | """ |
---|
45 | if value is not None: |
---|
46 | node = doc.createElement(name) |
---|
47 | node.appendChild(doc.createTextNode(str(value))) |
---|
48 | for item in attr: |
---|
49 | node.setAttribute(item, attr[item]) |
---|
50 | parent.appendChild(node) |
---|
51 | return True |
---|
52 | return False |
---|
53 | |
---|
54 | def get_node_text(node): |
---|
55 | """ |
---|
56 | Get the text context of a node |
---|
57 | |
---|
58 | @param node: node to read from |
---|
59 | @return: content, attribute list |
---|
60 | """ |
---|
61 | content = None |
---|
62 | attr = {} |
---|
63 | for item in node.childNodes: |
---|
64 | if item.nodeName.find('text')>=0 \ |
---|
65 | and len(item.nodeValue.strip())>0: |
---|
66 | content = item.nodeValue.strip() |
---|
67 | break |
---|
68 | |
---|
69 | if node.hasAttributes(): |
---|
70 | for i in range(node.attributes.length): |
---|
71 | attr[node.attributes.item(i).nodeName] \ |
---|
72 | = node.attributes.item(i).nodeValue |
---|
73 | |
---|
74 | return content, attr |
---|
75 | |
---|
76 | def get_content(location, node): |
---|
77 | """ |
---|
78 | Get the first instance of the content of a xpath location |
---|
79 | |
---|
80 | @param location: xpath location |
---|
81 | @param node: node to start at |
---|
82 | """ |
---|
83 | value = None |
---|
84 | attr = {} |
---|
85 | nodes = xpath.Evaluate(location, node) |
---|
86 | if len(nodes)>0: |
---|
87 | try: |
---|
88 | # Skip comments and empty lines |
---|
89 | for item in nodes[0].childNodes: |
---|
90 | if item.nodeName.find('text')>=0 \ |
---|
91 | and len(item.nodeValue.strip())>0: |
---|
92 | value = item.nodeValue.strip() |
---|
93 | break |
---|
94 | |
---|
95 | if nodes[0].hasAttributes(): |
---|
96 | for i in range(nodes[0].attributes.length): |
---|
97 | attr[nodes[0].attributes.item(i).nodeName] \ |
---|
98 | = nodes[0].attributes.item(i).nodeValue |
---|
99 | except: |
---|
100 | # problem reading the node. Skip it and return that |
---|
101 | # nothing was found |
---|
102 | logging.error("cansas_reader.get_content: %s\n %s" % (location, sys.exc_value)) |
---|
103 | |
---|
104 | return value, attr |
---|
105 | |
---|
106 | def get_float(location, node): |
---|
107 | """ |
---|
108 | Get the content of a node as a float |
---|
109 | |
---|
110 | @param location: xpath location |
---|
111 | @param node: node to start at |
---|
112 | """ |
---|
113 | value = None |
---|
114 | attr = {} |
---|
115 | content, attr = get_content(location, node) |
---|
116 | if content is not None: |
---|
117 | try: |
---|
118 | value = float(content) |
---|
119 | except: |
---|
120 | # Could not pass, skip and return None |
---|
121 | logging.error("cansas_reader.get_float: could not convert '%s' to float" % content) |
---|
122 | |
---|
123 | return value, attr |
---|
124 | |
---|
125 | def _store_float(location, node, variable, storage): |
---|
126 | """ |
---|
127 | Get the content of a xpath location and store |
---|
128 | the result. Check that the units are compatible |
---|
129 | with the destination. The value is expected to |
---|
130 | be a float. |
---|
131 | |
---|
132 | The xpath location might or might not exist. |
---|
133 | If it does not exist, nothing is done |
---|
134 | |
---|
135 | @param location: xpath location to fetch |
---|
136 | @param node: node to read the data from |
---|
137 | @param variable: name of the data member to store it in [string] |
---|
138 | @param storage: data object that has the 'variable' data member |
---|
139 | |
---|
140 | @raise ValueError: raised when the units are not recognized |
---|
141 | """ |
---|
142 | value, attr = get_float(location, node) |
---|
143 | if value is not None: |
---|
144 | # If the entry has units, check to see that they are |
---|
145 | # compatible with what we currently have in the data object |
---|
146 | if attr.has_key('unit'): |
---|
147 | toks = variable.split('.') |
---|
148 | exec "local_unit = storage.%s_unit.lower()" % toks[0] |
---|
149 | if attr['unit'].lower()!=local_unit: |
---|
150 | if has_converter==True: |
---|
151 | try: |
---|
152 | conv = Converter(attr['unit']) |
---|
153 | exec "storage.%s = %g" % (variable, conv(value, units=local_unit)) |
---|
154 | except: |
---|
155 | raise ValueError, "CanSAS reader: could not convert %s unit [%s]; expecting [%s]\n %s" \ |
---|
156 | % (variable, attr['unit'], local_unit, sys.exc_value) |
---|
157 | else: |
---|
158 | raise ValueError, "CanSAS reader: unrecognized %s unit [%s]; expecting [%s]" \ |
---|
159 | % (variable, attr['unit'], local_unit) |
---|
160 | else: |
---|
161 | exec "storage.%s = value" % variable |
---|
162 | else: |
---|
163 | exec "storage.%s = value" % variable |
---|
164 | |
---|
165 | |
---|
166 | def _store_content(location, node, variable, storage): |
---|
167 | """ |
---|
168 | Get the content of a xpath location and store |
---|
169 | the result. The value is treated as a string. |
---|
170 | |
---|
171 | The xpath location might or might not exist. |
---|
172 | If it does not exist, nothing is done |
---|
173 | |
---|
174 | @param location: xpath location to fetch |
---|
175 | @param node: node to read the data from |
---|
176 | @param variable: name of the data member to store it in [string] |
---|
177 | @param storage: data object that has the 'variable' data member |
---|
178 | """ |
---|
179 | value, attr = get_content(location, node) |
---|
180 | if value is not None: |
---|
181 | exec "storage.%s = value" % variable |
---|
182 | |
---|
183 | |
---|
184 | class Reader: |
---|
185 | """ |
---|
186 | Class to load cansas 1D XML files |
---|
187 | |
---|
188 | Dependencies: |
---|
189 | The CanSas reader requires PyXML 0.8.4 or later. |
---|
190 | """ |
---|
191 | ## CanSAS version |
---|
192 | version = '1.0' |
---|
193 | ## File type |
---|
194 | type = ["CanSAS 1D files (*.xml)|*.xml"] |
---|
195 | ## List of allowed extensions |
---|
196 | ext=['.xml', '.XML'] |
---|
197 | |
---|
198 | def read(self, path): |
---|
199 | """ |
---|
200 | Load data file |
---|
201 | |
---|
202 | @param path: file path |
---|
203 | @return: Data1D object if a single SASentry was found, |
---|
204 | or a list of Data1D objects if multiple entries were found, |
---|
205 | or None of nothing was found |
---|
206 | @raise RuntimeError: when the file can't be opened |
---|
207 | @raise ValueError: when the length of the data vectors are inconsistent |
---|
208 | """ |
---|
209 | from xml.dom.minidom import parse |
---|
210 | |
---|
211 | output = [] |
---|
212 | |
---|
213 | if os.path.isfile(path): |
---|
214 | basename = os.path.basename(path) |
---|
215 | root, extension = os.path.splitext(basename) |
---|
216 | if extension.lower() in self.ext: |
---|
217 | |
---|
218 | dom = parse(path) |
---|
219 | |
---|
220 | # Check the format version number |
---|
221 | nodes = xpath.Evaluate('SASroot', dom) |
---|
222 | if nodes[0].hasAttributes(): |
---|
223 | for i in range(nodes[0].attributes.length): |
---|
224 | if nodes[0].attributes.item(i).nodeName=='version': |
---|
225 | if nodes[0].attributes.item(i).nodeValue != self.version: |
---|
226 | raise ValueError, "cansas_reader: unrecognized version number %s" % \ |
---|
227 | nodes[0].attributes.item(i).nodeValue |
---|
228 | |
---|
229 | entry_list = xpath.Evaluate('SASroot/SASentry', dom) |
---|
230 | for entry in entry_list: |
---|
231 | sas_entry = self._parse_entry(entry) |
---|
232 | sas_entry.filename = basename |
---|
233 | output.append(sas_entry) |
---|
234 | |
---|
235 | else: |
---|
236 | raise RuntimeError, "%s is not a file" % path |
---|
237 | |
---|
238 | # Return output consistent with the loader's api |
---|
239 | if len(output)==0: |
---|
240 | return None |
---|
241 | elif len(output)==1: |
---|
242 | return output[0] |
---|
243 | else: |
---|
244 | return output |
---|
245 | |
---|
246 | def _parse_entry(self, dom): |
---|
247 | """ |
---|
248 | Parse a SASentry |
---|
249 | |
---|
250 | @param node: SASentry node |
---|
251 | @return: Data1D object |
---|
252 | """ |
---|
253 | x = numpy.zeros(0) |
---|
254 | y = numpy.zeros(0) |
---|
255 | |
---|
256 | data_info = Data1D(x, y) |
---|
257 | |
---|
258 | # Look up title |
---|
259 | _store_content('Title', dom, 'title', data_info) |
---|
260 | # Look up run number |
---|
261 | _store_content('Run', dom, 'run', data_info) |
---|
262 | # Look up instrument name |
---|
263 | value, attr = get_content('SASinstrument', dom) |
---|
264 | if attr.has_key('name'): |
---|
265 | data_info.instrument = attr['name'] |
---|
266 | |
---|
267 | note_list = xpath.Evaluate('SASnote', dom) |
---|
268 | for note in note_list: |
---|
269 | try: |
---|
270 | note_value, note_attr = get_node_text(note) |
---|
271 | if note_value is not None: |
---|
272 | data_info.notes.append(note_value) |
---|
273 | except: |
---|
274 | logging.error("cansas_reader.read: error processing entry notes\n %s" % sys.exc_value) |
---|
275 | |
---|
276 | |
---|
277 | # Sample info ################### |
---|
278 | _store_content('SASsample/ID', |
---|
279 | dom, 'ID', data_info.sample) |
---|
280 | _store_float('SASsample/thickness', |
---|
281 | dom, 'thickness', data_info.sample) |
---|
282 | _store_float('SASsample/transmission', |
---|
283 | dom, 'transmission', data_info.sample) |
---|
284 | _store_float('SASsample/temperature', |
---|
285 | dom, 'temperature', data_info.sample) |
---|
286 | nodes = xpath.Evaluate('SASsample/details', dom) |
---|
287 | for item in nodes: |
---|
288 | try: |
---|
289 | detail_value, detail_attr = get_node_text(item) |
---|
290 | if detail_value is not None: |
---|
291 | data_info.sample.details.append(detail_value) |
---|
292 | except: |
---|
293 | logging.error("cansas_reader.read: error processing sample details\n %s" % sys.exc_value) |
---|
294 | |
---|
295 | # Position (as a vector) |
---|
296 | _store_float('SASsample/position/x', |
---|
297 | dom, 'position.x', data_info.sample) |
---|
298 | _store_float('SASsample/position/y', |
---|
299 | dom, 'position.y', data_info.sample) |
---|
300 | _store_float('SASsample/position/z', |
---|
301 | dom, 'position.z', data_info.sample) |
---|
302 | |
---|
303 | # Orientation (as a vector) |
---|
304 | _store_float('SASsample/orientation/roll', |
---|
305 | dom, 'orientation.x', data_info.sample) |
---|
306 | _store_float('SASsample/orientation/pitch', |
---|
307 | dom, 'orientation.y', data_info.sample) |
---|
308 | _store_float('SASsample/orientation/yaw', |
---|
309 | dom, 'orientation.z', data_info.sample) |
---|
310 | |
---|
311 | # Source info ################### |
---|
312 | value, attr = get_content('SASinstrument/SASsource', dom) |
---|
313 | if attr.has_key('name'): |
---|
314 | data_info.source.name = attr['name'] |
---|
315 | |
---|
316 | _store_content('SASinstrument/SASsource/radiation', |
---|
317 | dom, 'radiation', data_info.source) |
---|
318 | _store_content('SASinstrument/SASsource/beam_shape', |
---|
319 | dom, 'beam_shape', data_info.source) |
---|
320 | _store_float('SASinstrument/SASsource/wavelength', |
---|
321 | dom, 'wavelength', data_info.source) |
---|
322 | _store_float('SASinstrument/SASsource/wavelength_min', |
---|
323 | dom, 'wavelength_min', data_info.source) |
---|
324 | _store_float('SASinstrument/SASsource/wavelength_max', |
---|
325 | dom, 'wavelength_max', data_info.source) |
---|
326 | _store_float('SASinstrument/SASsource/wavelength_spread', |
---|
327 | dom, 'wavelength_spread', data_info.source) |
---|
328 | |
---|
329 | # Beam size (as a vector) |
---|
330 | _store_float('SASinstrument/SASsource/beam_size/x', |
---|
331 | dom, 'beam_size.x', data_info.source) |
---|
332 | _store_float('SASinstrument/SASsource/beam_size/y', |
---|
333 | dom, 'beam_size.y', data_info.source) |
---|
334 | _store_float('SASinstrument/SASsource/beam_size/z', |
---|
335 | dom, 'beam_size.z', data_info.source) |
---|
336 | |
---|
337 | # Collimation info ################### |
---|
338 | nodes = xpath.Evaluate('SASinstrument/SAScollimation', dom) |
---|
339 | for item in nodes: |
---|
340 | collim = Collimation() |
---|
341 | value, attr = get_node_text(item) |
---|
342 | if attr.has_key('name'): |
---|
343 | collim.name = attr['name'] |
---|
344 | _store_float('length', item, 'length', collim) |
---|
345 | |
---|
346 | # Look for apertures |
---|
347 | apert_list = xpath.Evaluate('aperture', item) |
---|
348 | for apert in apert_list: |
---|
349 | aperture = Aperture() |
---|
350 | |
---|
351 | # Get the name and type of the aperture |
---|
352 | ap_value, ap_attr = get_node_text(item) |
---|
353 | if ap_attr.has_key('name'): |
---|
354 | aperture.name = ap_attr['name'] |
---|
355 | if ap_attr.has_key('type'): |
---|
356 | aperture.type = ap_attr['type'] |
---|
357 | |
---|
358 | _store_float('distance', apert, 'distance', aperture) |
---|
359 | _store_float('size/x', apert, 'size.x', aperture) |
---|
360 | _store_float('size/y', apert, 'size.y', aperture) |
---|
361 | _store_float('size/z', apert, 'size.z', aperture) |
---|
362 | |
---|
363 | collim.aperture.append(aperture) |
---|
364 | |
---|
365 | data_info.collimation.append(collim) |
---|
366 | |
---|
367 | # Detector info ###################### |
---|
368 | nodes = xpath.Evaluate('SASinstrument/SASdetector', dom) |
---|
369 | for item in nodes: |
---|
370 | |
---|
371 | detector = Detector() |
---|
372 | |
---|
373 | _store_content('name', item, 'name', detector) |
---|
374 | _store_float('SDD', item, 'distance', detector) |
---|
375 | |
---|
376 | # Detector offset (as a vector) |
---|
377 | _store_float('offset/x', item, 'offset.x', detector) |
---|
378 | _store_float('offset/y', item, 'offset.y', detector) |
---|
379 | _store_float('offset/z', item, 'offset.z', detector) |
---|
380 | |
---|
381 | # Detector orientation (as a vector) |
---|
382 | _store_float('orientation/pitch', item, 'orientation.x', detector) |
---|
383 | _store_float('orientation/yaw', item, 'orientation.y', detector) |
---|
384 | _store_float('orientation/roll', item, 'orientation.z', detector) |
---|
385 | |
---|
386 | # Beam center (as a vector) |
---|
387 | _store_float('beam_center/x', item, 'beam_center.x', detector) |
---|
388 | _store_float('beam_center/y', item, 'beam_center.y', detector) |
---|
389 | _store_float('beam_center/z', item, 'beam_center.z', detector) |
---|
390 | |
---|
391 | # Pixel size (as a vector) |
---|
392 | _store_float('pixel_size/x', item, 'pixel_size.x', detector) |
---|
393 | _store_float('pixel_size/y', item, 'pixel_size.y', detector) |
---|
394 | _store_float('pixel_size/z', item, 'pixel_size.z', detector) |
---|
395 | |
---|
396 | _store_float('slit_length', item, 'slit_length', detector) |
---|
397 | |
---|
398 | data_info.detector.append(detector) |
---|
399 | |
---|
400 | # Processes info ###################### |
---|
401 | nodes = xpath.Evaluate('SASprocess', dom) |
---|
402 | for item in nodes: |
---|
403 | process = Process() |
---|
404 | _store_content('name', item, 'name', process) |
---|
405 | _store_content('date', item, 'date', process) |
---|
406 | _store_content('description', item, 'description', process) |
---|
407 | |
---|
408 | term_list = xpath.Evaluate('term', item) |
---|
409 | for term in term_list: |
---|
410 | try: |
---|
411 | term_value, term_attr = get_node_text(term) |
---|
412 | term_attr['value'] = term_value |
---|
413 | if term_value is not None: |
---|
414 | process.term.append(term_attr) |
---|
415 | except: |
---|
416 | logging.error("cansas_reader.read: error processing process term\n %s" % sys.exc_value) |
---|
417 | |
---|
418 | note_list = xpath.Evaluate('SASprocessnote', item) |
---|
419 | for note in note_list: |
---|
420 | try: |
---|
421 | note_value, note_attr = get_node_text(note) |
---|
422 | if note_value is not None: |
---|
423 | process.notes.append(note_value) |
---|
424 | except: |
---|
425 | logging.error("cansas_reader.read: error processing process notes\n %s" % sys.exc_value) |
---|
426 | |
---|
427 | |
---|
428 | data_info.process.append(process) |
---|
429 | |
---|
430 | |
---|
431 | # Data info ###################### |
---|
432 | nodes = xpath.Evaluate('SASdata/Idata', dom) |
---|
433 | x = numpy.zeros(0) |
---|
434 | y = numpy.zeros(0) |
---|
435 | dx = numpy.zeros(0) |
---|
436 | dy = numpy.zeros(0) |
---|
437 | |
---|
438 | for item in nodes: |
---|
439 | _x, attr = get_float('Q', item) |
---|
440 | _dx, attr = get_float('Qdev', item) |
---|
441 | if _dx == None: |
---|
442 | _dx = 0.0 |
---|
443 | if attr.has_key('unit') and attr['unit'].lower() != data_info.x_unit.lower(): |
---|
444 | raise ValueError, "CanSAS reader: unrecognized %s unit [%s]; expecting [%s]" \ |
---|
445 | % (variable, attr['unit'], local_unit) |
---|
446 | |
---|
447 | _y, attr = get_float('I', item) |
---|
448 | _dy, attr = get_float('Idev', item) |
---|
449 | if _dy == None: |
---|
450 | _dy = 0.0 |
---|
451 | if attr.has_key('unit') and attr['unit'].lower() != data_info.y_unit.lower(): |
---|
452 | raise ValueError, "CanSAS reader: unrecognized %s unit [%s]; expecting [%s]" \ |
---|
453 | % (variable, attr['unit'], local_unit) |
---|
454 | |
---|
455 | if _x is not None and _y is not None: |
---|
456 | x = numpy.append(x, _x) |
---|
457 | y = numpy.append(x, _y) |
---|
458 | dx = numpy.append(x, _dx) |
---|
459 | dy = numpy.append(x, _dy) |
---|
460 | |
---|
461 | data_info.x = x |
---|
462 | data_info.y = y |
---|
463 | data_info.dx = dx |
---|
464 | data_info.dy = dy |
---|
465 | |
---|
466 | data_conv_q = None |
---|
467 | data_conv_i = None |
---|
468 | |
---|
469 | if has_converter == True and data_info.x_unit != '1/A': |
---|
470 | data_conv_q = Converter('1/A') |
---|
471 | # Test it |
---|
472 | data_conv_q(1.0, output.Q_unit) |
---|
473 | |
---|
474 | if has_converter == True and data_info.y_unit != '1/cm': |
---|
475 | data_conv_i = Converter('1/cm') |
---|
476 | # Test it |
---|
477 | data_conv_i(1.0, output.I_unit) |
---|
478 | |
---|
479 | |
---|
480 | if data_conv_q is not None: |
---|
481 | data_info.xaxis("\\rm{Q}", data_info.x_unit) |
---|
482 | else: |
---|
483 | data_info.xaxis("\\rm{Q}", 'A^{-1}') |
---|
484 | if data_conv_i is not None: |
---|
485 | data_info.yaxis("\\{I(Q)}", data_info.y_unit) |
---|
486 | else: |
---|
487 | data_info.yaxis("\\rm{I(Q)}","cm^{-1}") |
---|
488 | |
---|
489 | return data_info |
---|
490 | |
---|
491 | def write(self, filename, datainfo): |
---|
492 | """ |
---|
493 | Write the content of a Data1D as a CanSAS XML file |
---|
494 | |
---|
495 | @param filename: name of the file to write |
---|
496 | @param datainfo: Data1D object |
---|
497 | """ |
---|
498 | |
---|
499 | if not datainfo.__class__ == Data1D: |
---|
500 | raise RuntimeError, "The cansas writer expects a Data1D instance" |
---|
501 | |
---|
502 | doc = xml.dom.minidom.Document() |
---|
503 | main_node = doc.createElement("SASroot") |
---|
504 | main_node.setAttribute("version", "1.0") |
---|
505 | doc.appendChild(main_node) |
---|
506 | |
---|
507 | entry_node = doc.createElement("SASentry") |
---|
508 | main_node.appendChild(entry_node) |
---|
509 | |
---|
510 | write_node(doc, entry_node, "title", datainfo.title) |
---|
511 | write_node(doc, entry_node, "run", datainfo.run) |
---|
512 | |
---|
513 | # Data info |
---|
514 | node = doc.createElement("SASdata") |
---|
515 | entry_node.appendChild(node) |
---|
516 | |
---|
517 | # Sample info |
---|
518 | sample = doc.createElement("SASsample") |
---|
519 | entry_node.appendChild(sample) |
---|
520 | write_node(doc, sample, "ID", datainfo.sample.ID) |
---|
521 | write_node(doc, sample, "thickness", datainfo.sample.thickness, {"unit":datainfo.sample.thickness_unit}) |
---|
522 | write_node(doc, sample, "transmission", datainfo.sample.transmission) |
---|
523 | write_node(doc, sample, "temperature", datainfo.sample.temperature, {"unit":datainfo.sample.temperature_unit}) |
---|
524 | |
---|
525 | for item in datainfo.sample.details: |
---|
526 | write_node(doc, sample, "details", item) |
---|
527 | |
---|
528 | pos = doc.createElement("position") |
---|
529 | written = False |
---|
530 | written = written or write_node(doc, pos, "x", datainfo.sample.position.x, {"unit":datainfo.sample.position_unit}) |
---|
531 | written = written or write_node(doc, pos, "y", datainfo.sample.position.y, {"unit":datainfo.sample.position_unit}) |
---|
532 | written = written or write_node(doc, pos, "z", datainfo.sample.position.z, {"unit":datainfo.sample.position_unit}) |
---|
533 | if written == True: |
---|
534 | sample.appendChild(pos) |
---|
535 | |
---|
536 | ori = doc.createElement("orientation") |
---|
537 | written = False |
---|
538 | written = written or write_node(doc, ori, "roll", datainfo.sample.orientation.x, {"unit":datainfo.sample.orientation_unit}) |
---|
539 | written = written or write_node(doc, ori, "pitch", datainfo.sample.orientation.y, {"unit":datainfo.sample.orientation_unit}) |
---|
540 | written = written or write_node(doc, ori, "yaw", datainfo.sample.orientation.z, {"unit":datainfo.sample.orientation_unit}) |
---|
541 | if written == True: |
---|
542 | sample.appendChild(ori) |
---|
543 | |
---|
544 | # Instrument info |
---|
545 | instr = doc.createElement("SASinstrument") |
---|
546 | entry_node.appendChild(instr) |
---|
547 | |
---|
548 | write_node(doc, instr, "name", datainfo.instrument) |
---|
549 | |
---|
550 | # Source |
---|
551 | source = doc.createElement("SASsource") |
---|
552 | source.setAttribute("name", str(datainfo.source.name)) |
---|
553 | instr.appendChild(source) |
---|
554 | |
---|
555 | write_node(doc, source, "radiation", datainfo.source.radiation) |
---|
556 | write_node(doc, source, "beam_shape", datainfo.source.beam_shape) |
---|
557 | write_node(doc, source, "wavelength", datainfo.source.wavelength, {"unit":datainfo.source.wavelength_unit}) |
---|
558 | write_node(doc, source, "wavelength_min", datainfo.source.wavelength_min, {"unit":datainfo.source.wavelength_min_unit}) |
---|
559 | write_node(doc, source, "wavelength_max", datainfo.source.wavelength_max, {"unit":datainfo.source.wavelength_max_unit}) |
---|
560 | write_node(doc, source, "wavelength_spread", datainfo.source.wavelength_spread, {"unit":datainfo.source.wavelength_spread_unit}) |
---|
561 | |
---|
562 | # Collimation |
---|
563 | for item in datainfo.collimation: |
---|
564 | coll = doc.createElement("SAScollimation") |
---|
565 | coll.setAttribute("name", item.name) |
---|
566 | instr.appendChild(coll) |
---|
567 | |
---|
568 | write_node(doc, coll, "length", item.length, {"unit":item.length_unit}) |
---|
569 | |
---|
570 | for apert in item.aperture: |
---|
571 | ap = doc.createElement("SAScollimation") |
---|
572 | ap.setAttribute("name", apert.name) |
---|
573 | ap.setAttribute("type", apert.type) |
---|
574 | instr.appendChild(ap) |
---|
575 | |
---|
576 | write_node(doc, ap, "distance", apert.distance, {"unit":apert.distance_unit}) |
---|
577 | |
---|
578 | size = doc.createElement("size") |
---|
579 | ap.appendChild(size) |
---|
580 | write_node(doc, size, "x", apert.size.x, {"unit":apert.size_unit}) |
---|
581 | write_node(doc, size, "y", apert.size.y, {"unit":apert.size_unit}) |
---|
582 | write_node(doc, size, "z", apert.size.z, {"unit":apert.size_unit}) |
---|
583 | |
---|
584 | |
---|
585 | # Detectors |
---|
586 | for item in datainfo.detector: |
---|
587 | det = doc.createElement("SASdetector") |
---|
588 | instr.appendChild(det) |
---|
589 | |
---|
590 | write_node(doc, det, "name", item.name) |
---|
591 | write_node(doc, det, "SDD", item.distance, {"unit":item.distance_unit}) |
---|
592 | write_node(doc, det, "slit_length", item.slit_length, {"unit":item.slit_length_unit}) |
---|
593 | |
---|
594 | off = doc.createElement("offset") |
---|
595 | det.appendChild(off) |
---|
596 | write_node(doc, off, "x", item.offset.x, {"unit":item.offset_unit}) |
---|
597 | write_node(doc, off, "y", item.offset.y, {"unit":item.offset_unit}) |
---|
598 | write_node(doc, off, "z", item.offset.z, {"unit":item.offset_unit}) |
---|
599 | |
---|
600 | |
---|
601 | center = doc.createElement("beam_center") |
---|
602 | det.appendChild(center) |
---|
603 | write_node(doc, center, "x", item.beam_center.x, {"unit":item.beam_center_unit}) |
---|
604 | write_node(doc, center, "y", item.beam_center.y, {"unit":item.beam_center_unit}) |
---|
605 | write_node(doc, center, "z", item.beam_center.z, {"unit":item.beam_center_unit}) |
---|
606 | |
---|
607 | pix = doc.createElement("pixel_size") |
---|
608 | det.appendChild(pix) |
---|
609 | write_node(doc, pix, "x", item.pixel_size.x, {"unit":item.pixel_size_unit}) |
---|
610 | write_node(doc, pix, "y", item.pixel_size.y, {"unit":item.pixel_size_unit}) |
---|
611 | write_node(doc, pix, "z", item.pixel_size.z, {"unit":item.pixel_size_unit}) |
---|
612 | |
---|
613 | |
---|
614 | # Sample info |
---|
615 | for item in datainfo.process: |
---|
616 | node = doc.createElement("SASprocess") |
---|
617 | entry_node.appendChild(node) |
---|
618 | |
---|
619 | write_node(doc, entry_node, "run", item.name) |
---|
620 | |
---|
621 | |
---|
622 | # Write the file |
---|
623 | fd = open(filename, 'w') |
---|
624 | fd.write(doc.toprettyxml()) |
---|
625 | fd.close() |
---|
626 | |
---|
627 | |
---|
628 | if __name__ == "__main__": |
---|
629 | logging.basicConfig(level=logging.ERROR, |
---|
630 | format='%(asctime)s %(levelname)s %(message)s', |
---|
631 | filename='cansas_reader.log', |
---|
632 | filemode='w') |
---|
633 | reader = Reader() |
---|
634 | print reader.read("../test/cansas1d.xml") |
---|
635 | |
---|
636 | |
---|
637 | |
---|