source: sasview/DataLoader/readers/cansas_reader.py @ 8db3904

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.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 8db3904 was a01c743, checked in by Gervaise Alina <gervyh@…>, 14 years ago

raise an error when nothing can be read remove return none

  • Property mode set to 100644
File size: 40.2 KB
RevLine 
[8780e9a]1
2
[0997158f]3############################################################################
4#This software was developed by the University of Tennessee as part of the
5#Distributed Data Analysis of Neutron Scattering Experiments (DANSE)
6#project funded by the US National Science Foundation.
7#If you use DANSE applications to do scientific research that leads to
8#publication, we ask that you acknowledge the use of the software with the
9#following sentence:
10#This work benefited from DANSE software developed under NSF award DMR-0520547.
11#copyright 2008,2009 University of Tennessee
12#############################################################################
13
[579ba85]14# Known issue: reader not compatible with multiple SASdata entries
15# within a single SASentry. Will raise a runtime error.
[8780e9a]16
[a7a5886]17#TODO: check that all vectors are written only if they have at
18#    least one non-empty value
19#TODO: Writing only allows one SASentry per file.
20#     Would be best to allow multiple entries.
[8780e9a]21#TODO: Store error list
22#TODO: Allow for additional meta data for each section
[a7a5886]23#TODO: Notes need to be implemented. They can be any XML
24#    structure in version 1.0
[8780e9a]25#      Process notes have the same problem.
[e390933]26#TODO: Unit conversion is not complete (temperature units are missing)
[8780e9a]27
28
29import logging
30import numpy
[a7a5886]31import os
32import sys
33from DataLoader.data_info import Data1D
34from DataLoader.data_info import Collimation
35from DataLoader.data_info import Detector
36from DataLoader.data_info import Process
37from DataLoader.data_info import Aperture
[b0d0723]38from lxml import etree
39import xml.dom.minidom
[8780e9a]40
[b39c817]41has_converter = True
42try:
43    from data_util.nxsunit import Converter
44except:
45    has_converter = False
46
[b0d0723]47CANSAS_NS = "cansas1d/1.0"
48
[4c00964]49def write_node(doc, parent, name, value, attr={}):
50    """
[0997158f]51    :param doc: document DOM
52    :param parent: parent node
53    :param name: tag of the element
54    :param value: value of the child text node
55    :param attr: attribute dictionary
56   
57    :return: True if something was appended, otherwise False
[4c00964]58    """
59    if value is not None:
60        node = doc.createElement(name)
61        node.appendChild(doc.createTextNode(str(value)))
62        for item in attr:
63            node.setAttribute(item, attr[item])
64        parent.appendChild(node)
65        return True
66    return False
67
[8780e9a]68def get_content(location, node):
69    """
[0997158f]70    Get the first instance of the content of a xpath location.
71   
72    :param location: xpath location
73    :param node: node to start at
74   
75    :return: Element, or None
[8780e9a]76    """
[b0d0723]77    nodes = node.xpath(location, namespaces={'ns': CANSAS_NS})
78   
[8780e9a]79    if len(nodes)>0:
[b0d0723]80        return nodes[0]
81    else:
82        return None
[8780e9a]83
84def get_float(location, node):
85    """
[0997158f]86    Get the content of a node as a float
87   
88    :param location: xpath location
89    :param node: node to start at
[8780e9a]90    """
[b0d0723]91    nodes = node.xpath(location, namespaces={'ns': CANSAS_NS})
92   
[8780e9a]93    value = None
94    attr = {}
[a7a5886]95    if len(nodes) > 0:
[8780e9a]96        try:
[b0d0723]97            value = float(nodes[0].text)   
[8780e9a]98        except:
99            # Could not pass, skip and return None
[a7a5886]100            msg = "cansas_reader.get_float: could not "
101            msg += " convert '%s' to float" % nodes[0].text
102            logging.error(msg)
[b0d0723]103        if nodes[0].get('unit') is not None:
104            attr['unit'] = nodes[0].get('unit')
[8780e9a]105    return value, attr
106
[b39c817]107           
[8780e9a]108class Reader:
109    """
[0997158f]110    Class to load cansas 1D XML files
111   
112    :Dependencies:
113        The CanSas reader requires PyXML 0.8.4 or later.
[8780e9a]114    """
115    ## CanSAS version
116    version = '1.0'
117    ## File type
[28caa03]118    type_name = "CanSAS 1D"
119    ## Wildcards
[7406040]120    type = ["CanSAS 1D files (*.xml)|*.xml",
121                        "CanSAS 1D AVE files (*.AVEx)|*.AVEx",
122                         "CanSAS 1D AVE files (*.ABSx)|*.ABSx"]
123
[8780e9a]124    ## List of allowed extensions
[a7a5886]125    ext = ['.xml', '.XML','.avex', '.AVEx', '.absx', 'ABSx'] 
[8780e9a]126   
[fe78c7b]127    def __init__(self):
128        ## List of errors
129        self.errors = []
130   
[8780e9a]131    def read(self, path):
132        """
[0997158f]133        Load data file
134       
135        :param path: file path
136       
137        :return: Data1D object if a single SASentry was found,
138                    or a list of Data1D objects if multiple entries were found,
139                    or None of nothing was found
140                   
141        :raise RuntimeError: when the file can't be opened
142        :raise ValueError: when the length of the data vectors are inconsistent
[8780e9a]143        """
144        output = []
145        if os.path.isfile(path):
146            basename  = os.path.basename(path)
147            root, extension = os.path.splitext(basename)
148            if extension.lower() in self.ext:
149               
[b0d0723]150                tree = etree.parse(path, parser=etree.ETCompatXMLParser())
[8780e9a]151                # Check the format version number
[a7a5886]152                # Specifying the namespace will take care of the file
153                # format version
[b0d0723]154                root = tree.getroot()
155               
[a7a5886]156                entry_list = root.xpath('/ns:SASroot/ns:SASentry',
157                                         namespaces={'ns': CANSAS_NS})
[8780e9a]158               
159                for entry in entry_list:
[fe78c7b]160                    self.errors = []
[8780e9a]161                    sas_entry = self._parse_entry(entry)
162                    sas_entry.filename = basename
[fe78c7b]163                   
164                    # Store loading process information
165                    sas_entry.errors = self.errors
166                    sas_entry.meta_data['loader'] = self.type_name
[8780e9a]167                    output.append(sas_entry)
168               
169        else:
170            raise RuntimeError, "%s is not a file" % path
171        # Return output consistent with the loader's api
[a01c743]172        if len(output) == 0:
173            #cannot return none when it cannot read
174            #return None
175            raise RuntimeError, "%s cannot be read \n" % path
176        elif len(output) == 1:
[8780e9a]177            return output[0]
178        else:
179            return output               
180               
181    def _parse_entry(self, dom):
182        """
[0997158f]183        Parse a SASentry
184       
185        :param node: SASentry node
186       
187        :return: Data1D object
[8780e9a]188        """
189        x = numpy.zeros(0)
190        y = numpy.zeros(0)
191       
192        data_info = Data1D(x, y)
193       
[b0d0723]194        # Look up title     
[fe78c7b]195        self._store_content('ns:Title', dom, 'title', data_info)
[b0d0723]196       
[579ba85]197        # Look up run number   
[b0d0723]198        nodes = dom.xpath('ns:Run', namespaces={'ns': CANSAS_NS})
[579ba85]199        for item in nodes:   
[b0d0723]200            if item.text is not None:
201                value = item.text.strip()
202                if len(value) > 0:
203                    data_info.run.append(value)
204                    if item.get('name') is not None:
205                        data_info.run_name[value] = item.get('name')
[579ba85]206                           
[8780e9a]207        # Look up instrument name             
[a7a5886]208        self._store_content('ns:SASinstrument/ns:name', dom, 'instrument',
209                             data_info)
[8780e9a]210
[b0d0723]211        # Notes
212        note_list = dom.xpath('ns:SASnote', namespaces={'ns': CANSAS_NS})
[8780e9a]213        for note in note_list:
214            try:
[b0d0723]215                if note.text is not None:
216                    note_value = note.text.strip()
217                    if len(note_value) > 0:
218                        data_info.notes.append(note_value)
[8780e9a]219            except:
[a7a5886]220                err_mess = "cansas_reader.read: error processing"
221                err_mess += " entry notes\n  %s" % sys.exc_value
[fe78c7b]222                self.errors.append(err_mess)
223                logging.error(err_mess)
[8780e9a]224       
225        # Sample info ###################
[b0d0723]226        entry = get_content('ns:SASsample', dom)
227        if entry is not None:
228            data_info.sample.name = entry.get('name')
[579ba85]229           
[fe78c7b]230        self._store_content('ns:SASsample/ns:ID', 
[8780e9a]231                     dom, 'ID', data_info.sample)                   
[fe78c7b]232        self._store_float('ns:SASsample/ns:thickness', 
[8780e9a]233                     dom, 'thickness', data_info.sample)
[fe78c7b]234        self._store_float('ns:SASsample/ns:transmission', 
[8780e9a]235                     dom, 'transmission', data_info.sample)
[fe78c7b]236        self._store_float('ns:SASsample/ns:temperature', 
[8780e9a]237                     dom, 'temperature', data_info.sample)
[b0d0723]238       
[a7a5886]239        nodes = dom.xpath('ns:SASsample/ns:details', 
240                          namespaces={'ns': CANSAS_NS})
[8780e9a]241        for item in nodes:
242            try:
[b0d0723]243                if item.text is not None:
244                    detail_value = item.text.strip()
245                    if len(detail_value) > 0:
246                        data_info.sample.details.append(detail_value)
[8780e9a]247            except:
[a7a5886]248                err_mess = "cansas_reader.read: error processing "
249                err_mess += " sample details\n  %s" % sys.exc_value
[fe78c7b]250                self.errors.append(err_mess)
251                logging.error(err_mess)
[8780e9a]252       
253        # Position (as a vector)
[fe78c7b]254        self._store_float('ns:SASsample/ns:position/ns:x', 
[8780e9a]255                     dom, 'position.x', data_info.sample)         
[fe78c7b]256        self._store_float('ns:SASsample/ns:position/ns:y', 
[8780e9a]257                     dom, 'position.y', data_info.sample)         
[fe78c7b]258        self._store_float('ns:SASsample/ns:position/ns:z', 
[8780e9a]259                     dom, 'position.z', data_info.sample)         
260       
261        # Orientation (as a vector)
[fe78c7b]262        self._store_float('ns:SASsample/ns:orientation/ns:roll', 
[8780e9a]263                     dom, 'orientation.x', data_info.sample)         
[fe78c7b]264        self._store_float('ns:SASsample/ns:orientation/ns:pitch', 
[8780e9a]265                     dom, 'orientation.y', data_info.sample)         
[fe78c7b]266        self._store_float('ns:SASsample/ns:orientation/ns:yaw', 
[8780e9a]267                     dom, 'orientation.z', data_info.sample)         
268       
269        # Source info ###################
[b0d0723]270        entry = get_content('ns:SASinstrument/ns:SASsource', dom)
271        if entry is not None:
272            data_info.source.name = entry.get('name')
[4c00964]273       
[fe78c7b]274        self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation', 
[8780e9a]275                     dom, 'radiation', data_info.source)                   
[fe78c7b]276        self._store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape', 
[8780e9a]277                     dom, 'beam_shape', data_info.source)                   
[fe78c7b]278        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength', 
[8780e9a]279                     dom, 'wavelength', data_info.source)         
[fe78c7b]280        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min', 
[8780e9a]281                     dom, 'wavelength_min', data_info.source)         
[fe78c7b]282        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max', 
[8780e9a]283                     dom, 'wavelength_max', data_info.source)         
[fe78c7b]284        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread', 
[8780e9a]285                     dom, 'wavelength_spread', data_info.source)   
286       
[579ba85]287        # Beam size (as a vector)   
[b0d0723]288        entry = get_content('ns:SASinstrument/ns:SASsource/ns:beam_size', dom)
289        if entry is not None:
290            data_info.source.beam_size_name = entry.get('name')
[579ba85]291           
[fe78c7b]292        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x', 
[8780e9a]293                     dom, 'beam_size.x', data_info.source)   
[fe78c7b]294        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y', 
[8780e9a]295                     dom, 'beam_size.y', data_info.source)   
[fe78c7b]296        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z', 
[8780e9a]297                     dom, 'beam_size.z', data_info.source)   
298       
299        # Collimation info ###################
[a7a5886]300        nodes = dom.xpath('ns:SASinstrument/ns:SAScollimation', 
301                          namespaces={'ns': CANSAS_NS})
[8780e9a]302        for item in nodes:
303            collim = Collimation()
[b0d0723]304            if item.get('name') is not None:
305                collim.name = item.get('name')
[fe78c7b]306            self._store_float('ns:length', item, 'length', collim) 
[8780e9a]307           
308            # Look for apertures
[b0d0723]309            apert_list = item.xpath('ns:aperture', namespaces={'ns': CANSAS_NS})
[8780e9a]310            for apert in apert_list:
[d6513cd]311                aperture =  Aperture()
[4c00964]312               
313                # Get the name and type of the aperture
[b0d0723]314                aperture.name = apert.get('name')
315                aperture.type = apert.get('type')
[4c00964]316                   
[fe78c7b]317                self._store_float('ns:distance', apert, 'distance', aperture)   
[579ba85]318               
[b0d0723]319                entry = get_content('ns:size', apert)
320                if entry is not None:
321                    aperture.size_name = entry.get('name')
[579ba85]322               
[fe78c7b]323                self._store_float('ns:size/ns:x', apert, 'size.x', aperture)   
324                self._store_float('ns:size/ns:y', apert, 'size.y', aperture)   
325                self._store_float('ns:size/ns:z', apert, 'size.z', aperture)
[8780e9a]326               
327                collim.aperture.append(aperture)
328               
329            data_info.collimation.append(collim)
330       
331        # Detector info ######################
[a7a5886]332        nodes = dom.xpath('ns:SASinstrument/ns:SASdetector',
333                           namespaces={'ns': CANSAS_NS})
[8780e9a]334        for item in nodes:
335           
336            detector = Detector()
337           
[fe78c7b]338            self._store_content('ns:name', item, 'name', detector)
339            self._store_float('ns:SDD', item, 'distance', detector)   
[8780e9a]340           
341            # Detector offset (as a vector)
[fe78c7b]342            self._store_float('ns:offset/ns:x', item, 'offset.x', detector)   
343            self._store_float('ns:offset/ns:y', item, 'offset.y', detector)   
344            self._store_float('ns:offset/ns:z', item, 'offset.z', detector)   
[8780e9a]345           
346            # Detector orientation (as a vector)
[a7a5886]347            self._store_float('ns:orientation/ns:roll',  item, 'orientation.x',
348                               detector)   
349            self._store_float('ns:orientation/ns:pitch', item, 'orientation.y',
350                               detector)   
351            self._store_float('ns:orientation/ns:yaw',   item, 'orientation.z',
352                               detector)   
[8780e9a]353           
354            # Beam center (as a vector)
[a7a5886]355            self._store_float('ns:beam_center/ns:x', item, 'beam_center.x',
356                               detector)   
357            self._store_float('ns:beam_center/ns:y', item, 'beam_center.y', 
358                              detector)   
359            self._store_float('ns:beam_center/ns:z', item, 'beam_center.z',
360                               detector)   
[8780e9a]361           
362            # Pixel size (as a vector)
[a7a5886]363            self._store_float('ns:pixel_size/ns:x', item, 'pixel_size.x',
364                               detector)   
365            self._store_float('ns:pixel_size/ns:y', item, 'pixel_size.y',
366                               detector)   
367            self._store_float('ns:pixel_size/ns:z', item, 'pixel_size.z',
368                               detector)   
[8780e9a]369           
[fe78c7b]370            self._store_float('ns:slit_length', item, 'slit_length', detector)
[8780e9a]371           
372            data_info.detector.append(detector)   
373
374        # Processes info ######################
[b0d0723]375        nodes = dom.xpath('ns:SASprocess', namespaces={'ns': CANSAS_NS})
[8780e9a]376        for item in nodes:
377            process = Process()
[fe78c7b]378            self._store_content('ns:name', item, 'name', process)
379            self._store_content('ns:date', item, 'date', process)
380            self._store_content('ns:description', item, 'description', process)
[8780e9a]381           
[b0d0723]382            term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS})
[8780e9a]383            for term in term_list:
384                try:
[b0d0723]385                    term_attr = {}
386                    for attr in term.keys():
387                        term_attr[attr] = term.get(attr).strip()
388                    if term.text is not None:
389                        term_attr['value'] = term.text.strip()
[8780e9a]390                        process.term.append(term_attr)
391                except:
[a7a5886]392                    err_mess = "cansas_reader.read: error processing "
393                    err_mess += " process term\n  %s" % sys.exc_value
[fe78c7b]394                    self.errors.append(err_mess)
395                    logging.error(err_mess)
[8780e9a]396           
[a7a5886]397            note_list = item.xpath('ns:SASprocessnote', 
398                                   namespaces={'ns': CANSAS_NS})
[8780e9a]399            for note in note_list:
[b0d0723]400                if note.text is not None:
401                    process.notes.append(note.text.strip())
[8780e9a]402           
403            data_info.process.append(process)
404           
405           
406        # Data info ######################
[b0d0723]407        nodes = dom.xpath('ns:SASdata', namespaces={'ns': CANSAS_NS})
[a7a5886]408        if len(nodes) > 1:
409            msg = "CanSAS reader is not compatible with multiple"
410            msg += " SASdata entries"
411            raise RuntimeError, msg
[579ba85]412       
[b0d0723]413        nodes = dom.xpath('ns:SASdata/ns:Idata', namespaces={'ns': CANSAS_NS})
414
[8780e9a]415        x  = numpy.zeros(0)
416        y  = numpy.zeros(0)
417        dx = numpy.zeros(0)
418        dy = numpy.zeros(0)
[d00f8ff]419        dxw = numpy.zeros(0)
420        dxl = numpy.zeros(0)
[8780e9a]421       
422        for item in nodes:
[b0d0723]423            _x, attr = get_float('ns:Q', item)
424            _dx, attr_d = get_float('ns:Qdev', item)
425            _dxl, attr_l = get_float('ns:dQl', item)
426            _dxw, attr_w = get_float('ns:dQw', item)
[8780e9a]427            if _dx == None:
428                _dx = 0.0
[d00f8ff]429            if _dxl == None:
430                _dxl = 0.0
431            if _dxw == None:
432                _dxw = 0.0
[8780e9a]433               
[a7a5886]434            if attr.has_key('unit') and \
435                attr['unit'].lower() != data_info.x_unit.lower():
[e390933]436                if has_converter==True:
437                    try:
438                        data_conv_q = Converter(attr['unit'])
439                        _x = data_conv_q(_x, units=data_info.x_unit)
440                    except:
[a7a5886]441                        msg =  "CanSAS reader: could not convert "
442                        msg += "Q unit [%s]; " 
443                        msg += "expecting [%s]\n  %s" % (attr['unit'], 
444                                  data_info.x_unit, sys.exc_value)
445                        raise ValueError, msg
446                       
[e390933]447                else:
[a7a5886]448                    msg = "CanSAS reader: unrecognized Q unit [%s]; "
449                    msg += "expecting [%s]" % (attr['unit'], data_info.x_unit)
450                    raise ValueError, msg
451                       
[d00f8ff]452            # Error in Q
[a7a5886]453            if attr_d.has_key('unit') and \
454                attr_d['unit'].lower() != data_info.x_unit.lower():
[e390933]455                if has_converter==True:
456                    try:
457                        data_conv_q = Converter(attr_d['unit'])
458                        _dx = data_conv_q(_dx, units=data_info.x_unit)
459                    except:
[a7a5886]460                        msg = "CanSAS reader: could not convert dQ unit [%s];"
461                        msg += " expecting " 
462                        msg += "[%s]\n  %s" % (attr['unit'],
463                                                data_info.x_unit, sys.exc_value)
464                        raise ValueError, msg
465                       
[e390933]466                else:
[a7a5886]467                    msg = "CanSAS reader: unrecognized dQ unit [%s]; "
468                    msg += "expecting [%s]" % (attr['unit'], data_info.x_unit)
469                    raise ValueError,  msg
470                       
[d00f8ff]471            # Slit length
[a7a5886]472            if attr_l.has_key('unit') and \
473                attr_l['unit'].lower() != data_info.x_unit.lower():
474                if has_converter == True:
[d00f8ff]475                    try:
476                        data_conv_q = Converter(attr_l['unit'])
477                        _dxl = data_conv_q(_dxl, units=data_info.x_unit)
478                    except:
[a7a5886]479                        msg = "CanSAS reader: could not convert dQl unit [%s];"
480                        msg += " expecting [%s]\n  %s" % (attr['unit'],
481                                             data_info.x_unit, sys.exc_value)
482                        raise ValueError, msg
483                       
[d00f8ff]484                else:
[a7a5886]485                    msg = "CanSAS reader: unrecognized dQl unit [%s];"
486                    msg += " expecting [%s]" % (attr['unit'], data_info.x_unit)
487                    raise ValueError, msg
488                       
[d00f8ff]489            # Slit width
[a7a5886]490            if attr_w.has_key('unit') and \
491            attr_w['unit'].lower() != data_info.x_unit.lower():
492                if has_converter == True:
[d00f8ff]493                    try:
494                        data_conv_q = Converter(attr_w['unit'])
495                        _dxw = data_conv_q(_dxw, units=data_info.x_unit)
496                    except:
[a7a5886]497                        msg = "CanSAS reader: could not convert dQw unit [%s];"
498                        msg += " expecting [%s]\n  %s" % (attr['unit'], 
499                                                data_info.x_unit, sys.exc_value)
500                        raise ValueError, msg
501                       
[d00f8ff]502                else:
[a7a5886]503                    msg = "CanSAS reader: unrecognized dQw unit [%s];"
504                    msg += " expecting [%s]" % (attr['unit'], data_info.x_unit)
505                    raise ValueError, msg   
[b0d0723]506            _y, attr = get_float('ns:I', item)
507            _dy, attr_d = get_float('ns:Idev', item)
[8780e9a]508            if _dy == None:
509                _dy = 0.0
[a7a5886]510            if attr.has_key('unit') and \
511            attr['unit'].lower() != data_info.y_unit.lower():
[e390933]512                if has_converter==True:
513                    try:
514                        data_conv_i = Converter(attr['unit'])
515                        _y = data_conv_i(_y, units=data_info.y_unit)
516                    except:
[a7a5886]517                        msg = "CanSAS reader: could not convert I(q) unit [%s];"
518                        msg += " expecting [%s]\n  %s" % (attr['unit'], 
519                                            data_info.y_unit, sys.exc_value)
520                        raise ValueError, msg
[e390933]521                else:
[a7a5886]522                    msg = "CanSAS reader: unrecognized I(q) unit [%s];"
523                    msg += " expecting [%s]" % (attr['unit'], data_info.y_unit)
524                    raise ValueError, msg
525                       
526            if attr_d.has_key('unit') and \
527            attr_d['unit'].lower() != data_info.y_unit.lower():
[e390933]528                if has_converter==True:
529                    try:
530                        data_conv_i = Converter(attr_d['unit'])
531                        _dy = data_conv_i(_dy, units=data_info.y_unit)
532                    except:
[a7a5886]533                        msg = "CanSAS reader: could not convert dI(q) unit "
534                        msg += "[%s]; expecting [%s]\n  %s"  % (attr_d['unit'],
535                                             data_info.y_unit, sys.exc_value)
536                        raise ValueError, msg
[e390933]537                else:
[a7a5886]538                    msg = "CanSAS reader: unrecognized dI(q) unit [%s]; "
539                    msg += "expecting [%s]" % (attr_d['unit'], data_info.y_unit)
540                    raise ValueError, msg
[8780e9a]541               
542            if _x is not None and _y is not None:
543                x  = numpy.append(x, _x)
[579ba85]544                y  = numpy.append(y, _y)
545                dx = numpy.append(dx, _dx)
546                dy = numpy.append(dy, _dy)
[d00f8ff]547                dxl = numpy.append(dxl, _dxl)
548                dxw = numpy.append(dxw, _dxw)
549               
[8780e9a]550        data_info.x = x
551        data_info.y = y
552        data_info.dx = dx
553        data_info.dy = dy
[d00f8ff]554        data_info.dxl = dxl
555        data_info.dxw = dxw
[d6513cd]556       
557        data_conv_q = None
558        data_conv_i = None
559       
[ca10d8e]560        if has_converter == True and data_info.x_unit != '1/A':
561            data_conv_q = Converter('1/A')
[d6513cd]562            # Test it
563            data_conv_q(1.0, output.Q_unit)
564           
[ca10d8e]565        if has_converter == True and data_info.y_unit != '1/cm':
566            data_conv_i = Converter('1/cm')
[d6513cd]567            # Test it
[e390933]568            data_conv_i(1.0, output.I_unit)                   
569               
[99d1af6]570        if data_conv_q is not None:
[d6513cd]571            data_info.xaxis("\\rm{Q}", data_info.x_unit)
[99d1af6]572        else:
573            data_info.xaxis("\\rm{Q}", 'A^{-1}')
574        if data_conv_i is not None:
[0e2aa40]575            data_info.yaxis("\\rm{Intensity}", data_info.y_unit)
[99d1af6]576        else:
[0e2aa40]577            data_info.yaxis("\\rm{Intensity}","cm^{-1}")
[99d1af6]578       
[8780e9a]579        return data_info
580
[b3de3a45]581    def _to_xml_doc(self, datainfo):
[4c00964]582        """
[0997158f]583        Create an XML document to contain the content of a Data1D
584       
585        :param datainfo: Data1D object
[4c00964]586        """
587       
[7d8094b]588        if not issubclass(datainfo.__class__, Data1D):
[4c00964]589            raise RuntimeError, "The cansas writer expects a Data1D instance"
590       
591        doc = xml.dom.minidom.Document()
592        main_node = doc.createElement("SASroot")
[fee780b]593        main_node.setAttribute("version", self.version)
594        main_node.setAttribute("xmlns", "cansas1d/%s" % self.version)
[a7a5886]595        main_node.setAttribute("xmlns:xsi",
596                               "http://www.w3.org/2001/XMLSchema-instance")
597        main_node.setAttribute("xsi:schemaLocation",
598                               "cansas1d/%s http://svn.smallangles.net/svn/canSAS/1dwg/trunk/cansas1d.xsd" % self.version)
[fee780b]599       
[4c00964]600        doc.appendChild(main_node)
601       
602        entry_node = doc.createElement("SASentry")
603        main_node.appendChild(entry_node)
604       
[579ba85]605        write_node(doc, entry_node, "Title", datainfo.title)
606        for item in datainfo.run:
607            runname = {}
[a7a5886]608            if datainfo.run_name.has_key(item) and \
609            len(str(datainfo.run_name[item]))>1:
[579ba85]610                runname = {'name': datainfo.run_name[item] }
611            write_node(doc, entry_node, "Run", item, runname)
[4c00964]612       
613        # Data info
614        node = doc.createElement("SASdata")
615        entry_node.appendChild(node)
616       
[579ba85]617        for i in range(len(datainfo.x)):
618            pt = doc.createElement("Idata")
619            node.appendChild(pt)
620            write_node(doc, pt, "Q", datainfo.x[i], {'unit':datainfo.x_unit})
621            if len(datainfo.y)>=i:
[a7a5886]622                write_node(doc, pt, "I", datainfo.y[i],
623                            {'unit':datainfo.y_unit})
[5b396b3]624            if datainfo.dx !=None and len(datainfo.dx)>=i:
[a7a5886]625                write_node(doc, pt, "Qdev", datainfo.dx[i],
626                            {'unit':datainfo.x_unit})
[f31701c]627            if datainfo.dy !=None and len(datainfo.dy)>=i:
[a7a5886]628                write_node(doc, pt, "Idev", datainfo.dy[i],
629                            {'unit':datainfo.y_unit})
[579ba85]630
631       
[4c00964]632        # Sample info
633        sample = doc.createElement("SASsample")
[579ba85]634        if datainfo.sample.name is not None:
635            sample.setAttribute("name", str(datainfo.sample.name))
[4c00964]636        entry_node.appendChild(sample)
[579ba85]637        write_node(doc, sample, "ID", str(datainfo.sample.ID))
[a7a5886]638        write_node(doc, sample, "thickness", datainfo.sample.thickness,
639                   {"unit":datainfo.sample.thickness_unit})
[4c00964]640        write_node(doc, sample, "transmission", datainfo.sample.transmission)
[a7a5886]641        write_node(doc, sample, "temperature", datainfo.sample.temperature,
642                   {"unit":datainfo.sample.temperature_unit})
[4c00964]643       
644        for item in datainfo.sample.details:
645            write_node(doc, sample, "details", item)
646       
647        pos = doc.createElement("position")
[a7a5886]648        written = write_node(doc, pos, "x", datainfo.sample.position.x,
649                             {"unit":datainfo.sample.position_unit})
650        written = written | write_node(doc, pos, "y",
651                                       datainfo.sample.position.y,
652                                       {"unit":datainfo.sample.position_unit})
653        written = written | write_node(doc, pos, "z",
654                                       datainfo.sample.position.z,
655                                       {"unit":datainfo.sample.position_unit})
[4c00964]656        if written == True:
657            sample.appendChild(pos)
658       
659        ori = doc.createElement("orientation")
[a7a5886]660        written = write_node(doc, ori, "roll",
661                             datainfo.sample.orientation.x,
662                             {"unit":datainfo.sample.orientation_unit})
663        written = written | write_node(doc, ori, "pitch",
664                                       datainfo.sample.orientation.y,
665                                    {"unit":datainfo.sample.orientation_unit})
666        written = written | write_node(doc, ori, "yaw",
667                                       datainfo.sample.orientation.z,
668                                    {"unit":datainfo.sample.orientation_unit})
[4c00964]669        if written == True:
670            sample.appendChild(ori)
671       
672        # Instrument info
673        instr = doc.createElement("SASinstrument")
674        entry_node.appendChild(instr)
675       
676        write_node(doc, instr, "name", datainfo.instrument)
677       
678        #   Source
679        source = doc.createElement("SASsource")
[579ba85]680        if datainfo.source.name is not None:
681            source.setAttribute("name", str(datainfo.source.name))
[4c00964]682        instr.appendChild(source)
683       
684        write_node(doc, source, "radiation", datainfo.source.radiation)
685        write_node(doc, source, "beam_shape", datainfo.source.beam_shape)
[579ba85]686        size = doc.createElement("beam_size")
687        if datainfo.source.beam_size_name is not None:
688            size.setAttribute("name", str(datainfo.source.beam_size_name))
[a7a5886]689        written = write_node(doc, size, "x", datainfo.source.beam_size.x,
690                             {"unit":datainfo.source.beam_size_unit})
691        written = written | write_node(doc, size, "y",
692                                       datainfo.source.beam_size.y,
693                                       {"unit":datainfo.source.beam_size_unit})
694        written = written | write_node(doc, size, "z",
695                                       datainfo.source.beam_size.z,
696                                       {"unit":datainfo.source.beam_size_unit})
[579ba85]697        if written == True:
698            source.appendChild(size)
699           
[a7a5886]700        write_node(doc, source, "wavelength",
701                   datainfo.source.wavelength,
702                   {"unit":datainfo.source.wavelength_unit})
703        write_node(doc, source, "wavelength_min",
704                   datainfo.source.wavelength_min,
705                   {"unit":datainfo.source.wavelength_min_unit})
706        write_node(doc, source, "wavelength_max",
707                   datainfo.source.wavelength_max,
708                   {"unit":datainfo.source.wavelength_max_unit})
709        write_node(doc, source, "wavelength_spread",
710                   datainfo.source.wavelength_spread,
711                   {"unit":datainfo.source.wavelength_spread_unit})
[4c00964]712       
713        #   Collimation
714        for item in datainfo.collimation:
715            coll = doc.createElement("SAScollimation")
[579ba85]716            if item.name is not None:
717                coll.setAttribute("name", str(item.name))
[4c00964]718            instr.appendChild(coll)
719           
[a7a5886]720            write_node(doc, coll, "length", item.length,
721                       {"unit":item.length_unit})
[4c00964]722           
723            for apert in item.aperture:
[579ba85]724                ap = doc.createElement("aperture")
725                if apert.name is not None:
726                    ap.setAttribute("name", str(apert.name))
727                if apert.type is not None:
728                    ap.setAttribute("type", str(apert.type))
729                coll.appendChild(ap)
[4c00964]730               
[a7a5886]731                write_node(doc, ap, "distance", apert.distance,
732                           {"unit":apert.distance_unit})
[4c00964]733               
734                size = doc.createElement("size")
[579ba85]735                if apert.size_name is not None:
736                    size.setAttribute("name", str(apert.size_name))
[a7a5886]737                written = write_node(doc, size, "x", apert.size.x,
738                                     {"unit":apert.size_unit})
739                written = written | write_node(doc, size, "y", apert.size.y,
740                                               {"unit":apert.size_unit})
741                written = written | write_node(doc, size, "z", apert.size.z,
742                                               {"unit":apert.size_unit})
[579ba85]743                if written == True:
744                    ap.appendChild(size)
[4c00964]745
746        #   Detectors
747        for item in datainfo.detector:
748            det = doc.createElement("SASdetector")
[579ba85]749            written = write_node(doc, det, "name", item.name)
[a7a5886]750            written = written | write_node(doc, det, "SDD", item.distance,
751                                           {"unit":item.distance_unit})
752            written = written | write_node(doc, det, "slit_length",
753                                           item.slit_length,
754                                           {"unit":item.slit_length_unit})
[579ba85]755            if written == True:
756                instr.appendChild(det)
[4c00964]757           
758            off = doc.createElement("offset")
[a7a5886]759            written = write_node(doc, off, "x", item.offset.x,
760                                 {"unit":item.offset_unit})
761            written = written | write_node(doc, off, "y", item.offset.y,
762                                           {"unit":item.offset_unit})
763            written = written | write_node(doc, off, "z", item.offset.z,
764                                           {"unit":item.offset_unit})
[579ba85]765            if written == True:
766                det.appendChild(off)
[4c00964]767           
768            center = doc.createElement("beam_center")
[a7a5886]769            written = write_node(doc, center, "x", item.beam_center.x,
770                                 {"unit":item.beam_center_unit})
771            written = written | write_node(doc, center, "y",
772                                           item.beam_center.y,
773                                           {"unit":item.beam_center_unit})
774            written = written | write_node(doc, center, "z",
775                                           item.beam_center.z,
776                                           {"unit":item.beam_center_unit})
[579ba85]777            if written == True:
778                det.appendChild(center)
779               
[4c00964]780            pix = doc.createElement("pixel_size")
[a7a5886]781            written = write_node(doc, pix, "x", item.pixel_size.x,
782                                 {"unit":item.pixel_size_unit})
783            written = written | write_node(doc, pix, "y", item.pixel_size.y,
784                                           {"unit":item.pixel_size_unit})
785            written = written | write_node(doc, pix, "z", item.pixel_size.z,
786                                           {"unit":item.pixel_size_unit})
[579ba85]787            if written == True:
788                det.appendChild(pix)
789               
790            ori = doc.createElement("orientation")
[a7a5886]791            written = write_node(doc, ori, "roll",  item.orientation.x,
792                                 {"unit":item.orientation_unit})
793            written = written | write_node(doc, ori, "pitch",
794                                           item.orientation.y,
795                                           {"unit":item.orientation_unit})
796            written = written | write_node(doc, ori, "yaw",
797                                           item.orientation.z,
798                                           {"unit":item.orientation_unit})
[579ba85]799            if written == True:
800                det.appendChild(ori)
801               
[4c00964]802       
[579ba85]803        # Processes info
[4c00964]804        for item in datainfo.process:
805            node = doc.createElement("SASprocess")
806            entry_node.appendChild(node)
807
[579ba85]808            write_node(doc, node, "name", item.name)
809            write_node(doc, node, "date", item.date)
810            write_node(doc, node, "description", item.description)
811            for term in item.term:
812                value = term['value']
813                del term['value']
814                write_node(doc, node, "term", value, term)
815            for note in item.notes:
816                write_node(doc, node, "SASprocessnote", note)
[4c00964]817       
[b3de3a45]818        # Return the document, and the SASentry node associated with
819        # the data we just wrote
820        return doc, entry_node
821           
822    def write(self, filename, datainfo):
823        """
[0997158f]824        Write the content of a Data1D as a CanSAS XML file
825       
826        :param filename: name of the file to write
827        :param datainfo: Data1D object
[b3de3a45]828        """
829        # Create XML document
830        doc, sasentry = self._to_xml_doc(datainfo)
[4c00964]831        # Write the file
832        fd = open(filename, 'w')
833        fd.write(doc.toprettyxml())
834        fd.close()
835       
[fe78c7b]836    def _store_float(self, location, node, variable, storage, optional=True):
837        """
[0997158f]838        Get the content of a xpath location and store
839        the result. Check that the units are compatible
840        with the destination. The value is expected to
841        be a float.
842       
843        The xpath location might or might not exist.
844        If it does not exist, nothing is done
845       
846        :param location: xpath location to fetch
847        :param node: node to read the data from
848        :param variable: name of the data member to store it in [string]
849        :param storage: data object that has the 'variable' data member
[a7a5886]850        :param optional: if True, no exception will be raised
851            if unit conversion can't be done
[0997158f]852
853        :raise ValueError: raised when the units are not recognized
[fe78c7b]854        """
855        entry = get_content(location, node)
856        try:
857            value = float(entry.text)
858        except:
859            value = None
860           
861        if value is not None:
862            # If the entry has units, check to see that they are
863            # compatible with what we currently have in the data object
864            units = entry.get('unit')
865            if units is not None:
866                toks = variable.split('.')
867                exec "local_unit = storage.%s_unit" % toks[0]
868                if units.lower()!=local_unit.lower():
869                    if has_converter==True:
870                        try:
871                            conv = Converter(units)
[a7a5886]872                            exec "storage.%s = %g" % (variable,
873                                            conv(value, units=local_unit))
[fe78c7b]874                        except:
[a7a5886]875                            err_mess = "CanSAS reader: could not convert"
876                            err_mess += " %s unit [%s]; expecting [%s]\n  %s" \
[fe78c7b]877                                % (variable, units, local_unit, sys.exc_value)
878                            self.errors.append(err_mess)
879                            if optional:
880                                logging.info(err_mess)
881                            else:
882                                raise ValueError, err_mess
883                    else:
[a7a5886]884                        err_mess = "CanSAS reader: unrecognized %s unit [%s];"
885                        err_mess += " expecting [%s]" % (variable, 
886                                                         units, local_unit)
[fe78c7b]887                        self.errors.append(err_mess)
888                        if optional:
889                            logging.info(err_mess)
890                        else:
891                            raise ValueError, err_mess
892                else:
893                    exec "storage.%s = value" % variable
894            else:
895                exec "storage.%s = value" % variable
896               
897    def _store_content(self, location, node, variable, storage):
898        """
[0997158f]899        Get the content of a xpath location and store
900        the result. The value is treated as a string.
901       
902        The xpath location might or might not exist.
903        If it does not exist, nothing is done
904       
905        :param location: xpath location to fetch
906        :param node: node to read the data from
907        :param variable: name of the data member to store it in [string]
908        :param storage: data object that has the 'variable' data member
909       
910        :return: return a list of errors
[fe78c7b]911        """
912        entry = get_content(location, node)
913        if entry is not None and entry.text is not None:
914            exec "storage.%s = entry.text.strip()" % variable
915
916           
917           
[8780e9a]918if __name__ == "__main__": 
919    logging.basicConfig(level=logging.ERROR,
920                        format='%(asctime)s %(levelname)s %(message)s',
921                        filename='cansas_reader.log',
922                        filemode='w')
923    reader = Reader()
924    print reader.read("../test/cansas1d.xml")
[b0d0723]925    #print reader.read("../test/latex_smeared.xml")
[8780e9a]926   
927   
928                       
Note: See TracBrowser for help on using the repository browser.