Changeset fe78c7b in sasview


Ignore:
Timestamp:
Sep 5, 2009 9:45:29 AM (15 years ago)
Author:
Mathieu Doucet <doucetm@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
7d8c41f
Parents:
4deaec6
Message:

DataLoader?: exception no longer raised when units are wrong for an entry; the entry is not loaded and an error is logged instead. Loader info is now stored.

Location:
DataLoader
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • DataLoader/.pydevproject

    ra3f8d58 rfe78c7b  
    33 
    44<pydev_project> 
    5 <pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH"> 
    6 <path>/DataLoader/src</path> 
    7 <path>/DataLoader/extensions</path> 
    8 </pydev_pathproperty> 
    95<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.5</pydev_property> 
    10 <pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property> 
     6<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">C:\Python25\python.exe</pydev_property> 
    117</pydev_project> 

  • DataLoader/data_info.py

    r7d8094b rfe78c7b  
    137137    """ 
    138138    ## Name of the instrument [string] 
    139     name = '' 
     139    name = None 
    140140    ## Sample to detector distance [float] [mm] 
    141141    distance = None 
    … …  
    155155    ## Slit length of the instrument for this detector.[float] [mm] 
    156156    slit_length = None 
    157     #slit_length_unit = '1/A' 
    158157    slit_length_unit = 'mm' 
    159158     
    … …  
    207206    """ 
    208207    ## Name 
    209     name = '' 
     208    name = None 
    210209    ## Length [float] [mm] 
    211210    length = None 

  • DataLoader/readers/IgorReader.py

    r28caa03 rfe78c7b  
    290290            output.zaxis("\\rm{Intensity}","cm^{-1}") 
    291291     
    292          
     292        # Store loading process information 
     293        output.meta_data['loader'] = self.type_name 
    293294        return output 
    294295     

  • DataLoader/readers/abs_reader.py

    r28caa03 rfe78c7b  
    222222                else: 
    223223                    output.yaxis("\\rm{Intensity}","cm^{-1}") 
     224                     
     225                # Store loading process information 
     226                output.meta_data['loader'] = self.type_name                        
    224227                return output 
    225228        else: 

  • DataLoader/readers/ascii_reader.py

    re082e2c rfe78c7b  
    308308                else: 
    309309                    output.yaxis("\\rm{Intensity}","cm^{-1}") 
     310                     
     311                # Store loading process information 
     312                output.meta_data['loader'] = self.type_name     
     313                     
    310314                return output 
    311315             

  • DataLoader/readers/cansas_reader.py

    rb0d0723 rfe78c7b  
    9292    return value, attr 
    9393 
    94 def _store_float(location, node, variable, storage): 
    95     """ 
    96         Get the content of a xpath location and store 
    97         the result. Check that the units are compatible 
    98         with the destination. The value is expected to 
    99         be a float. 
    100          
    101         The xpath location might or might not exist. 
    102         If it does not exist, nothing is done 
    103          
    104         @param location: xpath location to fetch 
    105         @param node: node to read the data from 
    106         @param variable: name of the data member to store it in [string] 
    107         @param storage: data object that has the 'variable' data member 
    108          
    109         @raise ValueError: raised when the units are not recognized 
    110     """ 
    111     entry = get_content(location, node) 
    112     try: 
    113         value = float(entry.text) 
    114     except: 
    115         value = None 
    116          
    117     if value is not None: 
    118         # If the entry has units, check to see that they are 
    119         # compatible with what we currently have in the data object 
    120         units = entry.get('unit') 
    121         if units is not None: 
    122             toks = variable.split('.') 
    123             exec "local_unit = storage.%s_unit" % toks[0] 
    124             if units.lower()!=local_unit.lower(): 
    125                 if has_converter==True: 
    126                     try: 
    127                         conv = Converter(units) 
    128                         exec "storage.%s = %g" % (variable, conv(value, units=local_unit)) 
    129                     except: 
    130                         raise ValueError, "CanSAS reader: could not convert %s unit [%s]; expecting [%s]\n  %s" \ 
    131                         % (variable, units, local_unit, sys.exc_value) 
    132                 else: 
    133                     raise ValueError, "CanSAS reader: unrecognized %s unit [%s]; expecting [%s]" \ 
    134                         % (variable, units, local_unit) 
    135             else: 
    136                 exec "storage.%s = value" % variable 
    137         else: 
    138             exec "storage.%s = value" % variable 
    139              
    140  
    141 def _store_content(location, node, variable, storage): 
    142     """ 
    143         Get the content of a xpath location and store 
    144         the result. The value is treated as a string. 
    145          
    146         The xpath location might or might not exist. 
    147         If it does not exist, nothing is done 
    148          
    149         @param location: xpath location to fetch 
    150         @param node: node to read the data from 
    151         @param variable: name of the data member to store it in [string] 
    152         @param storage: data object that has the 'variable' data member 
    153     """ 
    154     entry = get_content(location, node) 
    155     if entry is not None and entry.text is not None: 
    156         exec "storage.%s = entry.text.strip()" % variable 
    157  
     94             
    15895 
    15996class Reader: 
    … …  
    173110    ext=['.xml', '.XML']   
    174111     
     112    def __init__(self): 
     113        ## List of errors 
     114        self.errors = [] 
     115     
    175116    def read(self, path): 
    176117        """  
    … …  
    199140                 
    200141                for entry in entry_list: 
     142                    self.errors = [] 
    201143                    sas_entry = self._parse_entry(entry) 
    202144                    sas_entry.filename = basename 
     145                     
     146                    # Store loading process information 
     147                    sas_entry.errors = self.errors 
     148                    sas_entry.meta_data['loader'] = self.type_name 
    203149                    output.append(sas_entry) 
    204150                 
    … …  
    227173         
    228174        # Look up title       
    229         _store_content('ns:Title', dom, 'title', data_info) 
     175        self._store_content('ns:Title', dom, 'title', data_info) 
    230176         
    231177        # Look up run number    
    … …  
    240186                            
    241187        # Look up instrument name               
    242         _store_content('ns:SASinstrument/ns:name', dom, 'instrument', data_info) 
     188        self._store_content('ns:SASinstrument/ns:name', dom, 'instrument', data_info) 
    243189 
    244190        # Notes 
    … …  
    251197                        data_info.notes.append(note_value) 
    252198            except: 
    253                 logging.error("cansas_reader.read: error processing entry notes\n  %s" % sys.exc_value) 
     199                err_mess = "cansas_reader.read: error processing entry notes\n  %s" % sys.exc_value 
     200                self.errors.append(err_mess) 
     201                logging.error(err_mess) 
    254202         
    255203        # Sample info ################### 
    … …  
    258206            data_info.sample.name = entry.get('name') 
    259207             
    260         _store_content('ns:SASsample/ns:ID',  
     208        self._store_content('ns:SASsample/ns:ID',  
    261209                     dom, 'ID', data_info.sample)                     
    262         _store_float('ns:SASsample/ns:thickness',  
     210        self._store_float('ns:SASsample/ns:thickness',  
    263211                     dom, 'thickness', data_info.sample) 
    264         _store_float('ns:SASsample/ns:transmission',  
     212        self._store_float('ns:SASsample/ns:transmission',  
    265213                     dom, 'transmission', data_info.sample) 
    266         _store_float('ns:SASsample/ns:temperature',  
     214        self._store_float('ns:SASsample/ns:temperature',  
    267215                     dom, 'temperature', data_info.sample) 
    268216         
    … …  
    275223                        data_info.sample.details.append(detail_value) 
    276224            except: 
    277                 logging.error("cansas_reader.read: error processing sample details\n  %s" % sys.exc_value) 
     225                err_mess = "cansas_reader.read: error processing sample details\n  %s" % sys.exc_value 
     226                self.errors.append(err_mess) 
     227                logging.error(err_mess) 
    278228         
    279229        # Position (as a vector) 
    280         _store_float('ns:SASsample/ns:position/ns:x',  
     230        self._store_float('ns:SASsample/ns:position/ns:x',  
    281231                     dom, 'position.x', data_info.sample)           
    282         _store_float('ns:SASsample/ns:position/ns:y',  
     232        self._store_float('ns:SASsample/ns:position/ns:y',  
    283233                     dom, 'position.y', data_info.sample)           
    284         _store_float('ns:SASsample/ns:position/ns:z',  
     234        self._store_float('ns:SASsample/ns:position/ns:z',  
    285235                     dom, 'position.z', data_info.sample)           
    286236         
    287237        # Orientation (as a vector) 
    288         _store_float('ns:SASsample/ns:orientation/ns:roll',  
     238        self._store_float('ns:SASsample/ns:orientation/ns:roll',  
    289239                     dom, 'orientation.x', data_info.sample)           
    290         _store_float('ns:SASsample/ns:orientation/ns:pitch',  
     240        self._store_float('ns:SASsample/ns:orientation/ns:pitch',  
    291241                     dom, 'orientation.y', data_info.sample)           
    292         _store_float('ns:SASsample/ns:orientation/ns:yaw',  
     242        self._store_float('ns:SASsample/ns:orientation/ns:yaw',  
    293243                     dom, 'orientation.z', data_info.sample)           
    294244        
    … …  
    298248            data_info.source.name = entry.get('name') 
    299249         
    300         _store_content('ns:SASinstrument/ns:SASsource/ns:radiation',  
     250        self._store_content('ns:SASinstrument/ns:SASsource/ns:radiation',  
    301251                     dom, 'radiation', data_info.source)                     
    302         _store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape',  
     252        self._store_content('ns:SASinstrument/ns:SASsource/ns:beam_shape',  
    303253                     dom, 'beam_shape', data_info.source)                     
    304         _store_float('ns:SASinstrument/ns:SASsource/ns:wavelength',  
     254        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength',  
    305255                     dom, 'wavelength', data_info.source)           
    306         _store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min',  
     256        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_min',  
    307257                     dom, 'wavelength_min', data_info.source)           
    308         _store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max',  
     258        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_max',  
    309259                     dom, 'wavelength_max', data_info.source)           
    310         _store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread',  
     260        self._store_float('ns:SASinstrument/ns:SASsource/ns:wavelength_spread',  
    311261                     dom, 'wavelength_spread', data_info.source)     
    312262         
    … …  
    316266            data_info.source.beam_size_name = entry.get('name') 
    317267             
    318         _store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x',  
     268        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:x',  
    319269                     dom, 'beam_size.x', data_info.source)     
    320         _store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y',  
     270        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:y',  
    321271                     dom, 'beam_size.y', data_info.source)     
    322         _store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z',  
     272        self._store_float('ns:SASinstrument/ns:SASsource/ns:beam_size/ns:z',  
    323273                     dom, 'beam_size.z', data_info.source)     
    324274         
    … …  
    329279            if item.get('name') is not None: 
    330280                collim.name = item.get('name') 
    331             _store_float('ns:length', item, 'length', collim)   
     281            self._store_float('ns:length', item, 'length', collim)   
    332282             
    333283            # Look for apertures 
    … …  
    340290                aperture.type = apert.get('type') 
    341291                     
    342                 _store_float('ns:distance', apert, 'distance', aperture)     
     292                self._store_float('ns:distance', apert, 'distance', aperture)     
    343293                 
    344294                entry = get_content('ns:size', apert) 
    … …  
    346296                    aperture.size_name = entry.get('name') 
    347297                 
    348                 _store_float('ns:size/ns:x', apert, 'size.x', aperture)     
    349                 _store_float('ns:size/ns:y', apert, 'size.y', aperture)     
    350                 _store_float('ns:size/ns:z', apert, 'size.z', aperture) 
     298                self._store_float('ns:size/ns:x', apert, 'size.x', aperture)     
     299                self._store_float('ns:size/ns:y', apert, 'size.y', aperture)     
     300                self._store_float('ns:size/ns:z', apert, 'size.z', aperture) 
    351301                 
    352302                collim.aperture.append(aperture) 
    … …  
    360310            detector = Detector() 
    361311             
    362             _store_content('ns:name', item, 'name', detector) 
    363             _store_float('ns:SDD', item, 'distance', detector)     
     312            self._store_content('ns:name', item, 'name', detector) 
     313            self._store_float('ns:SDD', item, 'distance', detector)     
    364314             
    365315            # Detector offset (as a vector) 
    366             _store_float('ns:offset/ns:x', item, 'offset.x', detector)     
    367             _store_float('ns:offset/ns:y', item, 'offset.y', detector)     
    368             _store_float('ns:offset/ns:z', item, 'offset.z', detector)     
     316            self._store_float('ns:offset/ns:x', item, 'offset.x', detector)     
     317            self._store_float('ns:offset/ns:y', item, 'offset.y', detector)     
     318            self._store_float('ns:offset/ns:z', item, 'offset.z', detector)     
    369319             
    370320            # Detector orientation (as a vector) 
    371             _store_float('ns:orientation/ns:roll',  item, 'orientation.x', detector)     
    372             _store_float('ns:orientation/ns:pitch', item, 'orientation.y', detector)     
    373             _store_float('ns:orientation/ns:yaw',   item, 'orientation.z', detector)     
     321            self._store_float('ns:orientation/ns:roll',  item, 'orientation.x', detector)     
     322            self._store_float('ns:orientation/ns:pitch', item, 'orientation.y', detector)     
     323            self._store_float('ns:orientation/ns:yaw',   item, 'orientation.z', detector)     
    374324             
    375325            # Beam center (as a vector) 
    376             _store_float('ns:beam_center/ns:x', item, 'beam_center.x', detector)     
    377             _store_float('ns:beam_center/ns:y', item, 'beam_center.y', detector)     
    378             _store_float('ns:beam_center/ns:z', item, 'beam_center.z', detector)     
     326            self._store_float('ns:beam_center/ns:x', item, 'beam_center.x', detector)     
     327            self._store_float('ns:beam_center/ns:y', item, 'beam_center.y', detector)     
     328            self._store_float('ns:beam_center/ns:z', item, 'beam_center.z', detector)     
    379329             
    380330            # Pixel size (as a vector) 
    381             _store_float('ns:pixel_size/ns:x', item, 'pixel_size.x', detector)     
    382             _store_float('ns:pixel_size/ns:y', item, 'pixel_size.y', detector)     
    383             _store_float('ns:pixel_size/ns:z', item, 'pixel_size.z', detector)     
    384              
    385             _store_float('ns:slit_length', item, 'slit_length', detector) 
     331            self._store_float('ns:pixel_size/ns:x', item, 'pixel_size.x', detector)     
     332            self._store_float('ns:pixel_size/ns:y', item, 'pixel_size.y', detector)     
     333            self._store_float('ns:pixel_size/ns:z', item, 'pixel_size.z', detector)     
     334             
     335            self._store_float('ns:slit_length', item, 'slit_length', detector) 
    386336             
    387337            data_info.detector.append(detector)     
    … …  
    391341        for item in nodes: 
    392342            process = Process() 
    393             _store_content('ns:name', item, 'name', process) 
    394             _store_content('ns:date', item, 'date', process) 
    395             _store_content('ns:description', item, 'description', process) 
     343            self._store_content('ns:name', item, 'name', process) 
     344            self._store_content('ns:date', item, 'date', process) 
     345            self._store_content('ns:description', item, 'description', process) 
    396346             
    397347            term_list = item.xpath('ns:term', namespaces={'ns': CANSAS_NS}) 
    … …  
    405355                        process.term.append(term_attr) 
    406356                except: 
    407                     logging.error("cansas_reader.read: error processing process term\n  %s" % sys.exc_value) 
     357                    err_mess = "cansas_reader.read: error processing process term\n  %s" % sys.exc_value 
     358                    self.errors.append(err_mess) 
     359                    logging.error(err_mess) 
    408360             
    409361            note_list = item.xpath('ns:SASprocessnote', namespaces={'ns': CANSAS_NS}) 
    … …  
    756708        fd.close() 
    757709         
    758          
     710    def _store_float(self, location, node, variable, storage, optional=True): 
     711        """ 
     712            Get the content of a xpath location and store 
     713            the result. Check that the units are compatible 
     714            with the destination. The value is expected to 
     715            be a float. 
     716             
     717            The xpath location might or might not exist. 
     718            If it does not exist, nothing is done 
     719             
     720            @param location: xpath location to fetch 
     721            @param node: node to read the data from 
     722            @param variable: name of the data member to store it in [string] 
     723            @param storage: data object that has the 'variable' data member 
     724            @param optional: if True, no exception will be raised if unit conversion can't be done 
     725     
     726            @raise ValueError: raised when the units are not recognized 
     727        """ 
     728        entry = get_content(location, node) 
     729        try: 
     730            value = float(entry.text) 
     731        except: 
     732            value = None 
     733             
     734        if value is not None: 
     735            # If the entry has units, check to see that they are 
     736            # compatible with what we currently have in the data object 
     737            units = entry.get('unit') 
     738            if units is not None: 
     739                toks = variable.split('.') 
     740                exec "local_unit = storage.%s_unit" % toks[0] 
     741                if units.lower()!=local_unit.lower(): 
     742                    if has_converter==True: 
     743                        try: 
     744                            conv = Converter(units) 
     745                            exec "storage.%s = %g" % (variable, conv(value, units=local_unit)) 
     746                        except: 
     747                            err_mess = "CanSAS reader: could not convert %s unit [%s]; expecting [%s]\n  %s" \ 
     748                                % (variable, units, local_unit, sys.exc_value) 
     749                            self.errors.append(err_mess) 
     750                            if optional: 
     751                                logging.info(err_mess) 
     752                            else: 
     753                                raise ValueError, err_mess  
     754                    else: 
     755                        err_mess = "CanSAS reader: unrecognized %s unit [%s]; expecting [%s]" \ 
     756                            % (variable, units, local_unit) 
     757                        self.errors.append(err_mess) 
     758                        if optional: 
     759                            logging.info(err_mess) 
     760                        else: 
     761                            raise ValueError, err_mess 
     762                else: 
     763                    exec "storage.%s = value" % variable 
     764            else: 
     765                exec "storage.%s = value" % variable 
     766                 
     767    def _store_content(self, location, node, variable, storage): 
     768        """ 
     769            Get the content of a xpath location and store 
     770            the result. The value is treated as a string. 
     771             
     772            The xpath location might or might not exist. 
     773            If it does not exist, nothing is done 
     774             
     775            @param location: xpath location to fetch 
     776            @param node: node to read the data from 
     777            @param variable: name of the data member to store it in [string] 
     778            @param storage: data object that has the 'variable' data member 
     779            @return: return a list of errors 
     780        """ 
     781        entry = get_content(location, node) 
     782        if entry is not None and entry.text is not None: 
     783            exec "storage.%s = entry.text.strip()" % variable 
     784 
     785             
     786             
    759787if __name__ == "__main__":  
    760788    logging.basicConfig(level=logging.ERROR, 

  • DataLoader/readers/danse_reader.py

    r28caa03 rfe78c7b  
    275275            else: 
    276276                logging.info("Danse_reader Reading %s \n"%filename) 
    277                 return output 
     277             
     278            # Store loading process information 
     279            output.meta_data['loader'] = self.type_name     
     280            return output 
    278281         
    279282        return None 

  • DataLoader/readers/hfir1d_reader.py

    r28caa03 rfe78c7b  
    120120                    output.yaxis("\\rm{Intensity}","cm^{-1}") 
    121121                 
     122                # Store loading process information 
     123                output.meta_data['loader'] = self.type_name    
    122124                return output 
    123125        else: 

  • DataLoader/readers/tiff_reader.py

    r28caa03 rfe78c7b  
    9595        output.ymax       = im.size[0]-1 
    9696         
     97        # Store loading process information 
     98        output.meta_data['loader'] = self.type_name  
    9799        return output 
    98100         

  • DataLoader/test/utest_abs_reader.py

    rd00f8ff rfe78c7b  
    1313     
    1414    def setUp(self): 
    15         self.data = Loader().load("jan08002.ABS") 
     15        from DataLoader.readers.abs_reader import Reader 
     16        self.data = Reader().read("jan08002.ABS") 
    1617         
    1718    def test_checkdata(self): 
    … …  
    2425        """ 
    2526        self.assertEqual(self.data.filename, "jan08002.ABS") 
     27        self.assertEqual(self.data.meta_data['loader'], "IGOR 1D") 
    2628         
    2729        self.assertEqual(self.data.source.wavelength_unit, 'A') 
    … …  
    6971        """ 
    7072        self.assertEqual(self.data.filename, "S2-30dq.d1d") 
     73        # THIS FILE FORMAT IS CURRENTLY READ BY THE ASCII READER 
     74        self.assertEqual(self.data.meta_data['loader'], "ASCII") 
    7175        self.assertEqual(len(self.data.x), 134) 
    7276        self.assertEqual(len(self.data.y), 134) 
    … …  
    9397        """ 
    9498        self.assertEqual(self.data.filename, "MAR07232_rest.ASC") 
     99        self.assertEqual(self.data.meta_data['loader'], "IGOR 2D") 
    95100         
    96101        self.assertEqual(self.data.source.wavelength_unit, 'A') 
    … …  
    127132        """ 
    128133        self.assertEqual(self.data.filename, "MP_New.sans") 
     134        self.assertEqual(self.data.meta_data['loader'], "DANSE") 
    129135         
    130136        self.assertEqual(self.data.source.wavelength_unit, 'A') 
    … …  
    169175         
    170176        self.assertEqual(self.data.run[0], "1234") 
     177        self.assertEqual(self.data.meta_data['loader'], "CanSAS 1D") 
     178        self.assertEqual(len(self.data.errors), 0) 
    171179         
    172180        # Data 
    … …  
    325333        self._checkdata() 
    326334         
     335    def test_badunits(self): 
     336        """ 
     337            Check units. 
     338            Note that not all units are available. 
     339        """ 
     340        filename = "cansas1d_badunits.xml" 
     341        self.data = Loader().load(filename) 
     342        self.assertEqual(self.data.filename, filename) 
     343        # The followed should not have been loaded 
     344        self.assertEqual(self.data.sample.thickness, None) 
     345        # This one should 
     346        self.assertEqual(self.data.sample.transmission, 0.327) 
     347         
     348        self.assertEqual(self.data.meta_data['loader'], "CanSAS 1D") 
     349        self.assertEqual(len(self.data.errors), 1) 
     350         
    327351         
    328352    def test_slits(self): 
    … …  
    356380 
    357381if __name__ == '__main__': 
     382    import logging 
     383    logging.basicConfig(level=logging.INFO, 
     384                        format='%(asctime)s %(levelname)s %(message)s', 
     385                        filename='utest_abs_reader.log', 
     386                        filemode='w') 
    358387    unittest.main() 
    359388    

  • DataLoader/test/utest_ascii.py

    raf76bd9 rfe78c7b  
    2424        self.assertEqual(f.x[0],0.002618) 
    2525        self.assertEqual(f.x[9],0.0497) 
     26         
     27        self.assertEqual(f.meta_data['loader'],"ASCII") 
    2628         
    2729    def test_truncated_1(self): 
Note: See TracChangeset for help on using the changeset viewer.