Changeset 35d518f in sasview


Ignore:
Timestamp:
Sep 17, 2017 12:12:44 PM (2 years ago)
Author:
butler
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, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
f9b61ca
Parents:
c245ca4 (diff), ca383a0 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge remote-tracking branch 'origin/master' into 898_imageviewer_file_selector

Files:
10 added
26 deleted
56 edited
1 moved

Legend:

Unmodified
Added
Removed
  • .pydevproject

    r26c8be3 r9d93c37  
    44<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property> 
    55<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH"> 
    6 <path>/sasview4/src</path> 
     6<path>/sasview/src</path> 
    77</pydev_pathproperty> 
    88</pydev_project> 
  • README.md

    r7a88adc rf9ba422  
    66 
    77[![Travis-CI Build Status](https://travis-ci.org/SasView/sasview.svg?branch=master)](https://travis-ci.org/SasView/sasview) 
    8  
     8[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.438138.svg)](https://doi.org/10.5281/zenodo.438138) 
  • docs/sphinx-docs/build_sphinx.py

    r01f1e17 r4abc05d8  
    3838#/sasview-local-trunk/docs/sphinx-docs/build_sphinx.py 
    3939SASMODELS_SOURCE_PROLOG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc") 
    40 SASMODELS_SOURCE_GPU = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "gpu") 
    41 SASMODELS_SOURCE_SESANS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "sesans") 
    42 SASMODELS_SOURCE_SESANSIMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "sesans", "sesans_img") 
    43 SASMODELS_SOURCE_MAGNETISM = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "magnetism") 
    44 SASMODELS_SOURCE_MAGIMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "magnetism", "mag_img") 
    45 SASMODELS_SOURCE_REF_MODELS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "ref", "models") 
     40SASMODELS_SOURCE_GPU = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "gpu") 
     41SASMODELS_SOURCE_SESANS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "sesans") 
     42SASMODELS_SOURCE_SESANSIMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "sesans", "sesans_img") 
     43SASMODELS_SOURCE_MAGNETISM = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "magnetism") 
     44SASMODELS_SOURCE_MAGIMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "magnetism", "mag_img") 
     45SASMODELS_SOURCE_REF_MODELS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "guide", "models") 
    4646SASMODELS_SOURCE_MODELS = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "model") 
    4747SASMODELS_SOURCE_IMG = os.path.join(CURRENT_SCRIPT_DIR, "..", "..", "..", "sasmodels", "doc", "model", "img") 
  • sasview/sasview.py

    rf36e01f r3b0f8cc  
    7474PLUGIN_MODEL_DIR = 'plugin_models' 
    7575APP_NAME = 'SasView' 
     76 
     77# Set SAS_MODELPATH so sasmodels can find our custom models 
     78os.environ['SAS_MODELPATH'] = os.path.join(sasdir, PLUGIN_MODEL_DIR) 
    7679 
    7780from matplotlib import backend_bases 
  • sasview/setup_exe.py

    ra1b8fee r5a8cdbb  
    228228# Copy the settings file for the sas.dataloader file extension associations 
    229229import sas.sascalc.dataloader.readers 
    230 f = os.path.join(sas.sascalc.dataloader.readers.get_data_path(), 'defaults.json') 
     230f = os.path.join(sas.sascalc.dataloader.readers.get_data_path()) 
    231231if os.path.isfile(f): 
    232232    data_files.append(('.', [f])) 
     
    242242if os.path.isfile(f): 
    243243    data_files.append(('.', [f])) 
    244  
    245 #f = 'default_categories.json' 
    246 #if os.path.isfile(f): 
    247 #    data_files.append(('.', [f])) 
    248244 
    249245# numerical libraries 
  • sasview/setup_mac.py

    ra1b8fee r5a8cdbb  
    5151 
    5252#CANSAxml reader data files 
    53 RESOURCES_FILES.append(os.path.join(sas.sascalc.dataloader.readers.get_data_path(),'defaults.json')) 
     53RESOURCES_FILES.append(os.path.join(sas.sascalc.dataloader.readers.get_data_path())) 
    5454 
    5555DATA_FILES.append('logging.ini') 
  • setup.py

    rb854587 r7a5d066  
    221221package_dir["sas.sascalc.dataloader"] = os.path.join( 
    222222    "src", "sas", "sascalc", "dataloader") 
    223 package_data["sas.sascalc.dataloader.readers"] = [ 
    224     'defaults.json', 'schema/*.xsd'] 
     223package_data["sas.sascalc.dataloader.readers"] = ['schema/*.xsd'] 
    225224packages.extend(["sas.sascalc.dataloader", "sas.sascalc.dataloader.readers", 
    226225                 "sas.sascalc.dataloader.readers.schema"]) 
  • src/sas/sascalc/data_util/registry.py

    ra1b8fee r5a8cdbb  
    1 # This program is public domain 
    21""" 
    32File extension registry. 
     
    87from __future__ import print_function 
    98 
    10 import os.path 
     9from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException 
     10 
    1111 
    1212class ExtensionRegistry(object): 
     
    2222        # Add an association by setting an element 
    2323        registry['.zip'] = unzip 
    24          
     24 
    2525        # Multiple extensions for one loader 
    2626        registry['.tgz'] = untar 
    2727        registry['.tar.gz'] = untar 
    2828 
    29         # Generic extensions to use after trying more specific extensions;  
     29        # Generic extensions to use after trying more specific extensions; 
    3030        # these will be checked after the more specific extensions fail. 
    3131        registry['.gz'] = gunzip 
     
    3838        # Show registered extensions 
    3939        print registry.extensions() 
    40          
     40 
    4141        # Can also register a format name for explicit control from caller 
    4242        registry['cx3'] = cx3 
     
    6262    def __init__(self, **kw): 
    6363        self.loaders = {} 
     64 
    6465    def __setitem__(self, ext, loader): 
    6566        if ext not in self.loaders: 
    6667            self.loaders[ext] = [] 
    6768        self.loaders[ext].insert(0,loader) 
     69 
    6870    def __getitem__(self, ext): 
    6971        return self.loaders[ext] 
     72 
    7073    def __contains__(self, ext): 
    7174        return ext in self.loaders 
     75 
    7276    def formats(self): 
    7377        """ 
     
    7781        names.sort() 
    7882        return names 
     83 
    7984    def extensions(self): 
    8085        """ 
     
    8489        exts.sort() 
    8590        return exts 
     91 
    8692    def lookup(self, path): 
    8793        """ 
    8894        Return the loader associated with the file type of path. 
    89          
    90         Raises ValueError if file type is not known. 
    91         """         
     95 
     96        :param path: Data file path 
     97        :raises ValueError: When no loaders are found for the file. 
     98        :return: List of available readers for the file extension 
     99        """ 
    92100        # Find matching extensions 
    93101        extlist = [ext for ext in self.extensions() if path.endswith(ext)] 
     
    106114        # Raise an error if there are no matching extensions 
    107115        if len(loaders) == 0: 
    108             raise ValueError, "Unknown file type for "+path 
    109         # All done 
     116            raise ValueError("Unknown file type for "+path) 
    110117        return loaders 
     118 
    111119    def load(self, path, format=None): 
    112120        """ 
    113121        Call the loader for the file type of path. 
    114122 
    115         Raises ValueError if no loader is available. 
    116         Raises KeyError if format is not available. 
    117         May raise a loader-defined exception if loader fails.         
     123        :raise ValueError: if no loader is available. 
     124        :raise KeyError: if format is not available. 
     125        May raise a loader-defined exception if loader fails. 
    118126        """ 
     127        loaders = [] 
    119128        if format is None: 
    120             loaders = self.lookup(path) 
     129            try: 
     130                loaders = self.lookup(path) 
     131            except ValueError as e: 
     132                pass 
    121133        else: 
    122             loaders = self.loaders[format] 
     134            try: 
     135                loaders = self.loaders[format] 
     136            except KeyError as e: 
     137                pass 
     138        last_exc = None 
    123139        for fn in loaders: 
    124140            try: 
    125141                return fn(path) 
    126             except: 
    127                 pass # give other loaders a chance to succeed 
     142            except Exception as e: 
     143                last_exc = e 
     144                pass  # give other loaders a chance to succeed 
    128145        # If we get here it is because all loaders failed 
    129         raise # reraises last exception 
    130  
    131 def test(): 
    132     reg = ExtensionRegistry() 
    133     class CxError(Exception): pass 
    134     def cx(file): return 'cx' 
    135     def new_cx(file): return 'new_cx' 
    136     def fail_cx(file): raise CxError 
    137     def cat(file): return 'cat' 
    138     def gunzip(file): return 'gunzip' 
    139     reg['.cx'] = cx 
    140     reg['.cx1'] = cx 
    141     reg['.cx'] = new_cx 
    142     reg['.gz'] = gunzip 
    143     reg['.cx.gz'] = new_cx 
    144     reg['.cx1.gz'] = fail_cx 
    145     reg['.cx1'] = fail_cx 
    146     reg['.cx2'] = fail_cx 
    147     reg['new_cx'] = new_cx 
    148  
    149     # Two loaders associated with .cx 
    150     assert reg.lookup('hello.cx') == [new_cx,cx] 
    151     # Make sure the last loader applies first 
    152     assert reg.load('hello.cx') == 'new_cx' 
    153     # Make sure the next loader applies if the first fails 
    154     assert reg.load('hello.cx1') == 'cx' 
    155     # Make sure the format override works 
    156     assert reg.load('hello.cx1',format='.cx.gz') == 'new_cx' 
    157     # Make sure the format override works 
    158     assert reg.load('hello.cx1',format='new_cx') == 'new_cx' 
    159     # Make sure the case of all loaders failing is correct 
    160     try:  reg.load('hello.cx2') 
    161     except CxError: pass # correct failure 
    162     else: raise AssertError,"Incorrect error on load failure" 
    163     # Make sure the case of no loaders fails correctly 
    164     try: reg.load('hello.missing') 
    165     except ValueError,msg: 
    166         assert str(msg)=="Unknown file type for hello.missing",'Message: <%s>'%(msg) 
    167     else: raise AssertError,"No error raised for missing extension" 
    168     assert reg.formats() == ['new_cx'] 
    169     assert reg.extensions() == ['.cx','.cx.gz','.cx1','.cx1.gz','.cx2','.gz'] 
    170     # make sure that it supports multiple '.' in filename 
    171     assert reg.load('hello.extra.cx1') == 'cx' 
    172     assert reg.load('hello.gz') == 'gunzip' 
    173     assert reg.load('hello.cx1.gz') == 'gunzip' # Since .cx1.gz fails 
    174  
    175 if __name__ == "__main__": test() 
     146        if last_exc is not None and len(loaders) != 0: 
     147            # If file has associated loader(s) and they;ve failed 
     148            raise last_exc 
     149        raise NoKnownLoaderException(e.message)  # raise generic exception 
  • src/sas/sascalc/dataloader/data_info.py

    ra1b8fee r17e257b5  
    11611161    final_dataset = None 
    11621162    if isinstance(data, plottable_1D): 
    1163         final_dataset = Data1D(data.x, data.y) 
     1163        final_dataset = Data1D(data.x, data.y, isSesans=datainfo.isSesans) 
    11641164        final_dataset.dx = data.dx 
    11651165        final_dataset.dy = data.dy 
    11661166        final_dataset.dxl = data.dxl 
    11671167        final_dataset.dxw = data.dxw 
     1168        final_dataset.x_unit = data._xunit 
     1169        final_dataset.y_unit = data._yunit 
    11681170        final_dataset.xaxis(data._xaxis, data._xunit) 
    11691171        final_dataset.yaxis(data._yaxis, data._yunit) 
     
    11811183        return return_string 
    11821184 
    1183     final_dataset.xmax = data.xmax 
    1184     final_dataset.ymax = data.ymax 
    1185     final_dataset.xmin = data.xmin 
    1186     final_dataset.ymin = data.ymin 
     1185    if hasattr(data, "xmax"): 
     1186        final_dataset.xmax = data.xmax 
     1187    if hasattr(data, "ymax"): 
     1188        final_dataset.ymax = data.ymax 
     1189    if hasattr(data, "xmin"): 
     1190        final_dataset.xmin = data.xmin 
     1191    if hasattr(data, "ymin"): 
     1192        final_dataset.ymin = data.ymin 
    11871193    final_dataset.isSesans = datainfo.isSesans 
    11881194    final_dataset.title = datainfo.title 
  • src/sas/sascalc/dataloader/loader.py

    r463e7ffc rdcb91cf  
    11""" 
    22    File handler to support different file extensions. 
    3     Uses reflectometry's registry utility. 
     3    Uses reflectometer registry utility. 
    44 
    55    The default readers are found in the 'readers' sub-module 
     
    1414""" 
    1515##################################################################### 
    16 #This software was developed by the University of Tennessee as part of the 
    17 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    18 #project funded by the US National Science Foundation. 
    19 #See the license text in license.txt 
    20 #copyright 2008, University of Tennessee 
     16# This software was developed by the University of Tennessee as part of the 
     17# Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     18# project funded by the US National Science Foundation. 
     19# See the license text in license.txt 
     20# copyright 2008, University of Tennessee 
    2121###################################################################### 
    2222 
     
    2929# Default readers are defined in the readers sub-module 
    3030import readers 
     31from loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
     32    DefaultReaderException 
    3133from readers import ascii_reader 
    3234from readers import cansas_reader 
     35from readers import cansas_reader_HDF5 
    3336 
    3437logger = logging.getLogger(__name__) 
     38 
    3539 
    3640class Registry(ExtensionRegistry): 
     
    3943    Readers and writers are supported. 
    4044    """ 
    41  
    4245    def __init__(self): 
    4346        super(Registry, self).__init__() 
    4447 
    45         ## Writers 
     48        # Writers 
    4649        self.writers = {} 
    4750 
    48         ## List of wildcards 
     51        # List of wildcards 
    4952        self.wildcards = ['All (*.*)|*.*'] 
    5053 
    51         ## Creation time, for testing 
     54        # Creation time, for testing 
    5255        self._created = time.time() 
    5356 
     
    6366            of a particular reader 
    6467 
    65         Defaults to the ascii (multi-column) reader 
    66         if no reader was registered for the file's 
    67         extension. 
    68         """ 
     68        Defaults to the ascii (multi-column), cansas XML, and cansas NeXuS 
     69        readers if no reader was registered for the file's extension. 
     70        """ 
     71        # Gets set to a string if the file has an associated reader that fails 
     72        msg_from_reader = None 
    6973        try: 
    7074            return super(Registry, self).load(path, format=format) 
    71         except: 
    72             try: 
    73                 # No reader was found. Default to the ascii reader. 
    74                 ascii_loader = ascii_reader.Reader() 
    75                 return ascii_loader.read(path) 
    76             except: 
    77                 cansas_loader = cansas_reader.Reader() 
    78                 return cansas_loader.read(path) 
     75        except NoKnownLoaderException as nkl_e: 
     76            pass  # Try the ASCII reader 
     77        except FileContentsException as fc_exc: 
     78            # File has an associated reader but it failed. 
     79            # Save the error message to display later, but try the 3 default loaders 
     80            msg_from_reader = fc_exc.message 
     81        except Exception: 
     82            pass 
     83 
     84        # File has no associated reader, or the associated reader failed. 
     85        # Try the ASCII reader 
     86        try: 
     87            ascii_loader = ascii_reader.Reader() 
     88            return ascii_loader.read(path) 
     89        except DefaultReaderException: 
     90            pass  # Loader specific error to try the cansas XML reader 
     91        except FileContentsException as e: 
     92            if msg_from_reader is None: 
     93                raise RuntimeError(e.message) 
     94 
     95        # ASCII reader failed - try CanSAS xML reader 
     96        try: 
     97            cansas_loader = cansas_reader.Reader() 
     98            return cansas_loader.read(path) 
     99        except DefaultReaderException: 
     100            pass  # Loader specific error to try the NXcanSAS reader 
     101        except FileContentsException as e: 
     102            if msg_from_reader is None: 
     103                raise RuntimeError(e.message) 
     104        except Exception: 
     105            pass 
     106 
     107        # CanSAS XML reader failed - try NXcanSAS reader 
     108        try: 
     109            cansas_nexus_loader = cansas_reader_HDF5.Reader() 
     110            return cansas_nexus_loader.read(path) 
     111        except DefaultReaderException as e: 
     112            logging.error("No default loader can load the data") 
     113            # No known reader available. Give up and throw an error 
     114            if msg_from_reader is None: 
     115                msg = "\nUnknown data format: {}.\nThe file is not a ".format(path) 
     116                msg += "known format that can be loaded by SasView.\n" 
     117                raise NoKnownLoaderException(msg) 
     118            else: 
     119                # Associated reader and default readers all failed. 
     120                # Show error message from associated reader 
     121                raise RuntimeError(msg_from_reader) 
     122        except FileContentsException as e: 
     123            err_msg = msg_from_reader if msg_from_reader is not None else e.message 
     124            raise RuntimeError(err_msg) 
    79125 
    80126    def find_plugins(self, dir): 
  • src/sas/sascalc/dataloader/readers/__init__.py

    r959eb01 r7a5d066  
    1 # Backward compatibility with the previous implementation of the default readers 
    2 from associations import register_readers 
     1# Method to associate extensions to default readers 
     2from associations import read_associations 
    33 
    4 # Method to associate extensions to default readers  
    5 from associations import read_associations 
    64 
    75# Method to return the location of the XML settings file 
  • src/sas/sascalc/dataloader/readers/abs_reader.py

    r959eb01 rad92c5a  
    11""" 
     2    IGOR 1D data reader 
    23""" 
    34##################################################################### 
    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 #See the license text in license.txt 
    8 #copyright 2008, University of Tennessee 
     5# This software was developed by the University of Tennessee as part of the 
     6# Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     7# project funded by the US National Science Foundation. 
     8# See the license text in license.txt 
     9# copyright 2008, University of Tennessee 
    910###################################################################### 
    1011 
     12import logging 
    1113import numpy as np 
    12 import os 
    13 from sas.sascalc.dataloader.data_info import Data1D 
    14 from sas.sascalc.dataloader.data_info import Detector 
    15  
    16 has_converter = True 
    17 try: 
    18     from sas.sascalc.data_util.nxsunit import Converter 
    19 except: 
    20     has_converter = False 
    21      
    22      
    23 class Reader: 
     14from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     15from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D, Data1D,\ 
     16    Detector 
     17from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\ 
     18    DefaultReaderException 
     19 
     20logger = logging.getLogger(__name__) 
     21 
     22 
     23class Reader(FileReader): 
    2424    """ 
    2525    Class to load IGOR reduced .ABS files 
    2626    """ 
    27     ## File type 
     27    # File type 
    2828    type_name = "IGOR 1D" 
    29     ## Wildcards 
     29    # Wildcards 
    3030    type = ["IGOR 1D files (*.abs)|*.abs"] 
    31     ## List of allowed extensions 
    32     ext = ['.abs', '.ABS'] 
     31    # List of allowed extensions 
     32    ext = ['.abs'] 
    3333     
    34     def read(self, path): 
     34    def get_file_contents(self): 
    3535        """  
    36         Load data file. 
    37          
    38         :param path: file path 
    39          
    40         :return: Data1D object, or None 
     36        Get the contents of the file 
    4137         
    4238        :raise RuntimeError: when the file can't be opened 
    4339        :raise ValueError: when the length of the data vectors are inconsistent 
    4440        """ 
    45         if os.path.isfile(path): 
    46             basename = os.path.basename(path) 
    47             root, extension = os.path.splitext(basename) 
    48             if extension.lower() in self.ext: 
    49                 try: 
    50                     input_f = open(path,'r') 
     41        buff = self.f_open.read() 
     42        filepath = self.f_open.name 
     43        lines = buff.splitlines() 
     44        self.has_converter = True 
     45        try: 
     46            from sas.sascalc.data_util.nxsunit import Converter 
     47        except: 
     48            self.has_converter = False 
     49        self.output = [] 
     50        self.current_datainfo = DataInfo() 
     51        self.current_datainfo.filename = filepath 
     52        self.reset_data_list(len(lines)) 
     53        detector = Detector() 
     54        data_line = 0 
     55        self.reset_data_list(len(lines)) 
     56        self.current_datainfo.detector.append(detector) 
     57        self.current_datainfo.filename = filepath 
     58 
     59        is_info = False 
     60        is_center = False 
     61        is_data_started = False 
     62 
     63        base_q_unit = '1/A' 
     64        base_i_unit = '1/cm' 
     65        data_conv_q = Converter(base_q_unit) 
     66        data_conv_i = Converter(base_i_unit) 
     67 
     68        for line in lines: 
     69            # Information line 1 
     70            if is_info: 
     71                is_info = False 
     72                line_toks = line.split() 
     73 
     74                # Wavelength in Angstrom 
     75                try: 
     76                    value = float(line_toks[1]) 
     77                    if self.has_converter and \ 
     78                            self.current_datainfo.source.wavelength_unit != 'A': 
     79                        conv = Converter('A') 
     80                        self.current_datainfo.source.wavelength = conv(value, 
     81                            units=self.current_datainfo.source.wavelength_unit) 
     82                    else: 
     83                        self.current_datainfo.source.wavelength = value 
     84                except KeyError: 
     85                    msg = "ABSReader cannot read wavelength from %s" % filepath 
     86                    self.current_datainfo.errors.append(msg) 
     87 
     88                # Detector distance in meters 
     89                try: 
     90                    value = float(line_toks[3]) 
     91                    if self.has_converter and detector.distance_unit != 'm': 
     92                        conv = Converter('m') 
     93                        detector.distance = conv(value, 
     94                                        units=detector.distance_unit) 
     95                    else: 
     96                        detector.distance = value 
    5197                except: 
    52                     raise  RuntimeError, "abs_reader: cannot open %s" % path 
    53                 buff = input_f.read() 
    54                 lines = buff.split('\n') 
    55                 x  = np.zeros(0) 
    56                 y  = np.zeros(0) 
    57                 dy = np.zeros(0) 
    58                 dx = np.zeros(0) 
    59                 output = Data1D(x, y, dy=dy, dx=dx) 
    60                 detector = Detector() 
    61                 output.detector.append(detector) 
    62                 output.filename = basename 
    63                  
    64                 is_info = False 
     98                    msg = "ABSReader cannot read SDD from %s" % filepath 
     99                    self.current_datainfo.errors.append(msg) 
     100 
     101                # Transmission 
     102                try: 
     103                    self.current_datainfo.sample.transmission = \ 
     104                        float(line_toks[4]) 
     105                except ValueError: 
     106                    # Transmission isn't always in the header 
     107                    pass 
     108 
     109                # Sample thickness in mm 
     110                try: 
     111                    value = float(line_toks[5]) 
     112                    if self.has_converter and \ 
     113                            self.current_datainfo.sample.thickness_unit != 'cm': 
     114                        conv = Converter('cm') 
     115                        self.current_datainfo.sample.thickness = conv(value, 
     116                            units=self.current_datainfo.sample.thickness_unit) 
     117                    else: 
     118                        self.current_datainfo.sample.thickness = value 
     119                except ValueError: 
     120                    # Thickness is not a mandatory entry 
     121                    pass 
     122 
     123            # MON CNT  LAMBDA  DET ANG  DET DIST  TRANS  THICK  AVE   STEP 
     124            if line.count("LAMBDA") > 0: 
     125                is_info = True 
     126 
     127            # Find center info line 
     128            if is_center: 
    65129                is_center = False 
    66                 is_data_started = False 
    67                  
    68                 data_conv_q = None 
    69                 data_conv_i = None 
    70                  
    71                 if has_converter == True and output.x_unit != '1/A': 
    72                     data_conv_q = Converter('1/A') 
    73                     # Test it 
    74                     data_conv_q(1.0, output.x_unit) 
    75                      
    76                 if has_converter == True and output.y_unit != '1/cm': 
    77                     data_conv_i = Converter('1/cm') 
    78                     # Test it 
    79                     data_conv_i(1.0, output.y_unit) 
    80                  
    81                 for line in lines: 
    82                      
    83                     # Information line 1 
    84                     if is_info == True: 
    85                         is_info = False 
    86                         line_toks = line.split() 
    87                          
    88                         # Wavelength in Angstrom 
    89                         try: 
    90                             value = float(line_toks[1]) 
    91                             if has_converter == True and \ 
    92                                 output.source.wavelength_unit != 'A': 
    93                                 conv = Converter('A') 
    94                                 output.source.wavelength = conv(value, 
    95                                         units=output.source.wavelength_unit) 
    96                             else: 
    97                                 output.source.wavelength = value 
    98                         except: 
    99                             #goes to ASC reader 
    100                             msg = "abs_reader: cannot open %s" % path 
    101                             raise  RuntimeError, msg 
    102                          
    103                         # Distance in meters 
    104                         try: 
    105                             value = float(line_toks[3]) 
    106                             if has_converter == True and \ 
    107                                 detector.distance_unit != 'm': 
    108                                 conv = Converter('m') 
    109                                 detector.distance = conv(value, 
    110                                                 units=detector.distance_unit) 
    111                             else: 
    112                                 detector.distance = value 
    113                         except: 
    114                             #goes to ASC reader 
    115                             msg = "abs_reader: cannot open %s" % path 
    116                             raise  RuntimeError, msg 
    117                         # Transmission 
    118                         try: 
    119                             output.sample.transmission = float(line_toks[4]) 
    120                         except: 
    121                             # Transmission is not a mandatory entry 
    122                             pass 
    123                      
    124                         # Thickness in mm 
    125                         try: 
    126                             value = float(line_toks[5]) 
    127                             if has_converter == True and \ 
    128                                 output.sample.thickness_unit != 'cm': 
    129                                 conv = Converter('cm') 
    130                                 output.sample.thickness = conv(value, 
    131                                             units=output.sample.thickness_unit) 
    132                             else: 
    133                                 output.sample.thickness = value 
    134                         except: 
    135                             # Thickness is not a mandatory entry 
    136                             pass 
    137                      
    138                     #MON CNT   LAMBDA   DET ANG   DET DIST   TRANS   THICK  
    139                     #  AVE   STEP 
    140                     if line.count("LAMBDA") > 0: 
    141                         is_info = True 
    142                          
    143                     # Find center info line 
    144                     if is_center == True: 
    145                         is_center = False 
    146                         line_toks = line.split() 
    147                         # Center in bin number 
    148                         center_x = float(line_toks[0]) 
    149                         center_y = float(line_toks[1]) 
    150                          
    151                         # Bin size 
    152                         if has_converter == True and \ 
    153                             detector.pixel_size_unit != 'mm': 
    154                             conv = Converter('mm') 
    155                             detector.pixel_size.x = conv(5.0, 
    156                                                 units=detector.pixel_size_unit) 
    157                             detector.pixel_size.y = conv(5.0, 
    158                                                 units=detector.pixel_size_unit) 
    159                         else: 
    160                             detector.pixel_size.x = 5.0 
    161                             detector.pixel_size.y = 5.0 
    162                          
    163                         # Store beam center in distance units 
    164                         # Det 640 x 640 mm 
    165                         if has_converter == True and \ 
    166                             detector.beam_center_unit != 'mm': 
    167                             conv = Converter('mm') 
    168                             detector.beam_center.x = conv(center_x * 5.0, 
    169                                              units=detector.beam_center_unit) 
    170                             detector.beam_center.y = conv(center_y * 5.0, 
    171                                             units=detector.beam_center_unit) 
    172                         else: 
    173                             detector.beam_center.x = center_x * 5.0 
    174                             detector.beam_center.y = center_y * 5.0 
    175                          
    176                         # Detector type 
    177                         try: 
    178                             detector.name = line_toks[7] 
    179                         except: 
    180                             # Detector name is not a mandatory entry 
    181                             pass 
    182                      
    183                     #BCENT(X,Y)   A1(mm)   A2(mm)   A1A2DIST(m)   DL/L 
    184                     #  BSTOP(mm)   DET_TYP 
    185                     if line.count("BCENT") > 0: 
    186                         is_center = True 
    187                          
    188                     # Parse the data 
    189                     if is_data_started == True: 
    190                         toks = line.split() 
    191  
    192                         try: 
    193                             _x  = float(toks[0]) 
    194                             _y  = float(toks[1]) 
    195                             _dy = float(toks[2]) 
    196                             _dx = float(toks[3]) 
    197                              
    198                             if data_conv_q is not None: 
    199                                 _x = data_conv_q(_x, units=output.x_unit) 
    200                                 _dx = data_conv_i(_dx, units=output.x_unit) 
    201                                  
    202                             if data_conv_i is not None: 
    203                                 _y = data_conv_i(_y, units=output.y_unit) 
    204                                 _dy = data_conv_i(_dy, units=output.y_unit) 
    205                             
    206                             x = np.append(x, _x) 
    207                             y = np.append(y, _y) 
    208                             dy = np.append(dy, _dy) 
    209                             dx = np.append(dx, _dx) 
    210                              
    211                         except: 
    212                             # Could not read this data line. If we are here 
    213                             # it is because we are in the data section. Just 
    214                             # skip it. 
    215                             pass 
    216                              
    217                     #The 6 columns are | Q (1/A) | I(Q) (1/cm) | std. dev. 
    218                     # I(Q) (1/cm) | sigmaQ | meanQ | ShadowFactor| 
    219                     if line.count("The 6 columns") > 0: 
    220                         is_data_started = True 
    221              
    222                 # Sanity check 
    223                 if not len(y) == len(dy): 
    224                     msg = "abs_reader: y and dy have different length" 
    225                     raise ValueError, msg 
    226                 # If the data length is zero, consider this as 
    227                 # though we were not able to read the file. 
    228                 if len(x) == 0: 
    229                     raise ValueError, "ascii_reader: could not load file" 
    230                  
    231                 output.x = x[x != 0] 
    232                 output.y = y[x != 0] 
    233                 output.dy = dy[x != 0] 
    234                 output.dx = dx[x != 0] 
    235                 if data_conv_q is not None: 
    236                     output.xaxis("\\rm{Q}", output.x_unit) 
     130                line_toks = line.split() 
     131                # Center in bin number 
     132                center_x = float(line_toks[0]) 
     133                center_y = float(line_toks[1]) 
     134 
     135                # Bin size 
     136                if self.has_converter and detector.pixel_size_unit != 'mm': 
     137                    conv = Converter('mm') 
     138                    detector.pixel_size.x = conv(5.08, 
     139                                        units=detector.pixel_size_unit) 
     140                    detector.pixel_size.y = conv(5.08, 
     141                                        units=detector.pixel_size_unit) 
    237142                else: 
    238                     output.xaxis("\\rm{Q}", 'A^{-1}') 
    239                 if data_conv_i is not None: 
    240                     output.yaxis("\\rm{Intensity}", output.y_unit) 
     143                    detector.pixel_size.x = 5.08 
     144                    detector.pixel_size.y = 5.08 
     145 
     146                # Store beam center in distance units 
     147                # Det 640 x 640 mm 
     148                if self.has_converter and detector.beam_center_unit != 'mm': 
     149                    conv = Converter('mm') 
     150                    detector.beam_center.x = conv(center_x * 5.08, 
     151                                     units=detector.beam_center_unit) 
     152                    detector.beam_center.y = conv(center_y * 5.08, 
     153                                    units=detector.beam_center_unit) 
    241154                else: 
    242                     output.yaxis("\\rm{Intensity}", "cm^{-1}") 
    243                      
    244                 # Store loading process information 
    245                 output.meta_data['loader'] = self.type_name 
    246                 return output 
     155                    detector.beam_center.x = center_x * 5.08 
     156                    detector.beam_center.y = center_y * 5.08 
     157 
     158                # Detector type 
     159                try: 
     160                    detector.name = line_toks[7] 
     161                except: 
     162                    # Detector name is not a mandatory entry 
     163                    pass 
     164 
     165            # BCENT(X,Y)  A1(mm)  A2(mm)  A1A2DIST(m)  DL/L  BSTOP(mm)  DET_TYP 
     166            if line.count("BCENT") > 0: 
     167                is_center = True 
     168 
     169            # Parse the data 
     170            if is_data_started: 
     171                toks = line.split() 
     172 
     173                try: 
     174                    _x = float(toks[0]) 
     175                    _y = float(toks[1]) 
     176                    _dy = float(toks[2]) 
     177                    _dx = float(toks[3]) 
     178 
     179                    if data_conv_q is not None: 
     180                        _x = data_conv_q(_x, units=base_q_unit) 
     181                        _dx = data_conv_q(_dx, units=base_q_unit) 
     182 
     183                    if data_conv_i is not None: 
     184                        _y = data_conv_i(_y, units=base_i_unit) 
     185                        _dy = data_conv_i(_dy, units=base_i_unit) 
     186 
     187                    self.current_dataset.x[data_line] = _x 
     188                    self.current_dataset.y[data_line] = _y 
     189                    self.current_dataset.dy[data_line] = _dy 
     190                    self.current_dataset.dx[data_line] = _dx 
     191                    data_line += 1 
     192 
     193                except ValueError: 
     194                    # Could not read this data line. If we are here 
     195                    # it is because we are in the data section. Just 
     196                    # skip it. 
     197                    pass 
     198 
     199            # The 6 columns are | Q (1/A) | I(Q) (1/cm) | std. dev. 
     200            # I(Q) (1/cm) | sigmaQ | meanQ | ShadowFactor| 
     201            if line.count("The 6 columns") > 0: 
     202                is_data_started = True 
     203 
     204        self.remove_empty_q_values(True, True) 
     205 
     206        # Sanity check 
     207        if not len(self.current_dataset.y) == len(self.current_dataset.dy): 
     208            self.set_all_to_none() 
     209            msg = "abs_reader: y and dy have different length" 
     210            raise ValueError(msg) 
     211        # If the data length is zero, consider this as 
     212        # though we were not able to read the file. 
     213        if len(self.current_dataset.x) == 0: 
     214            self.set_all_to_none() 
     215            raise ValueError("ascii_reader: could not load file") 
     216 
     217        if data_conv_q is not None: 
     218            self.current_dataset.xaxis("\\rm{Q}", base_q_unit) 
    247219        else: 
    248             raise RuntimeError, "%s is not a file" % path 
    249         return None 
     220            self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
     221        if data_conv_i is not None: 
     222            self.current_dataset.yaxis("\\rm{Intensity}", base_i_unit) 
     223        else: 
     224            self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 
     225 
     226        # Store loading process information 
     227        self.current_datainfo.meta_data['loader'] = self.type_name 
     228        self.send_to_output() 
  • src/sas/sascalc/dataloader/readers/anton_paar_saxs_reader.py

    ra235f715 rfafe52a  
    99 
    1010from sas.sascalc.dataloader.readers.xml_reader import XMLreader 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, Data1D, Sample, Source 
     11from sas.sascalc.dataloader.data_info import plottable_1D, Data1D, DataInfo, Sample, Source 
    1212from sas.sascalc.dataloader.data_info import Process, Aperture, Collimation, TransmissionSpectrum, Detector 
    13  
     13from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
    1414 
    1515class Reader(XMLreader): 
    1616    """ 
    17     A class for reading in CanSAS v2.0 data files. The existing iteration opens Mantid generated HDF5 formatted files 
    18     with file extension .h5/.H5. Any number of data sets may be present within the file and any dimensionality of data 
    19     may be used. Currently 1D and 2D SAS data sets are supported, but future implementations will include 1D and 2D 
    20     SESANS data. This class assumes a single data set for each sasentry. 
    21  
    22     :Dependencies: 
    23         The CanSAS HDF5 reader requires h5py v2.5.0 or later. 
     17    A class for reading in Anton Paar .pdh files 
    2418    """ 
    2519 
     
    3024    ## Raw file contents to be processed 
    3125    raw_data = None 
    32     ## Data set being modified 
    33     current_dataset = None 
    3426    ## For recursion and saving purposes, remember parent objects 
    3527    parent_list = None 
     
    4234    ## Flag to bypass extension check 
    4335    allow_all = False 
    44     ## List of files to return 
    45     output = None 
    4636 
    4737    def reset_state(self): 
    48         self.current_dataset = Data1D(np.empty(0), np.empty(0), 
    49                                             np.empty(0), np.empty(0)) 
     38        self.current_dataset = plottable_1D(np.empty(0), np.empty(0), np.empty(0), np.empty(0)) 
     39        self.current_datainfo = DataInfo() 
    5040        self.datasets = [] 
    5141        self.raw_data = None 
     
    6353        self.lower = 5 
    6454 
    65     def read(self, filename): 
     55    def get_file_contents(self): 
    6656        """ 
    6757            This is the general read method that all SasView data_loaders must have. 
     
    7363        ## Reinitialize the class when loading a new data file to reset all class variables 
    7464        self.reset_state() 
    75         ## Check that the file exists 
    76         if os.path.isfile(filename): 
    77             basename = os.path.basename(filename) 
    78             _, extension = os.path.splitext(basename) 
    79             # If the file type is not allowed, return empty list 
    80             if extension in self.ext or self.allow_all: 
    81                 ## Load the data file 
    82                 input_f = open(filename, 'r') 
    83                 buff = input_f.read() 
    84                 self.raw_data = buff.splitlines() 
    85                 self.read_data() 
    86         return self.output 
     65        buff = self.f_open.read() 
     66        self.raw_data = buff.splitlines() 
     67        self.read_data() 
    8768 
    8869    def read_data(self): 
     70        correctly_loaded = True 
     71        error_message = "" 
     72 
    8973        q_unit = "1/nm" 
    9074        i_unit = "1/um^2" 
    91         self.current_dataset.title = self.raw_data[0] 
    92         self.current_dataset.meta_data["Keywords"] = self.raw_data[1] 
    93         line3 = self.raw_data[2].split() 
    94         line4 = self.raw_data[3].split() 
    95         line5 = self.raw_data[4].split() 
    96         self.data_points = int(line3[0]) 
    97         self.lower = 5 
    98         self.upper = self.lower + self.data_points 
    99         self.source.radiation = 'x-ray' 
    100         normal = float(line4[3]) 
    101         self.current_dataset.source.radiation = "x-ray" 
    102         self.current_dataset.source.name = "Anton Paar SAXSess Instrument" 
    103         self.current_dataset.source.wavelength = float(line4[4]) 
    104         xvals = [] 
    105         yvals = [] 
    106         dyvals = [] 
    107         for i in range(self.lower, self.upper): 
    108             index = i - self.lower 
    109             data = self.raw_data[i].split() 
    110             xvals.insert(index, normal * float(data[0])) 
    111             yvals.insert(index, normal * float(data[1])) 
    112             dyvals.insert(index, normal * float(data[2])) 
     75        try: 
     76            self.current_datainfo.title = self.raw_data[0] 
     77            self.current_datainfo.meta_data["Keywords"] = self.raw_data[1] 
     78            line3 = self.raw_data[2].split() 
     79            line4 = self.raw_data[3].split() 
     80            line5 = self.raw_data[4].split() 
     81            self.data_points = int(line3[0]) 
     82            self.lower = 5 
     83            self.upper = self.lower + self.data_points 
     84            self.source.radiation = 'x-ray' 
     85            normal = float(line4[3]) 
     86            self.current_datainfo.source.radiation = "x-ray" 
     87            self.current_datainfo.source.name = "Anton Paar SAXSess Instrument" 
     88            self.current_datainfo.source.wavelength = float(line4[4]) 
     89            xvals = [] 
     90            yvals = [] 
     91            dyvals = [] 
     92            for i in range(self.lower, self.upper): 
     93                index = i - self.lower 
     94                data = self.raw_data[i].split() 
     95                xvals.insert(index, normal * float(data[0])) 
     96                yvals.insert(index, normal * float(data[1])) 
     97                dyvals.insert(index, normal * float(data[2])) 
     98        except Exception as e: 
     99            error_message = "Couldn't load {}.\n".format(self.f_open.name) 
     100            error_message += e.message 
     101            raise FileContentsException(error_message) 
    113102        self.current_dataset.x = np.append(self.current_dataset.x, xvals) 
    114103        self.current_dataset.y = np.append(self.current_dataset.y, yvals) 
    115104        self.current_dataset.dy = np.append(self.current_dataset.dy, dyvals) 
    116105        if self.data_points != self.current_dataset.x.size: 
    117             self.errors.add("Not all data was loaded properly.") 
    118         if self.current_dataset.dx.size != self.current_dataset.x.size: 
    119             dxvals = np.zeros(self.current_dataset.x.size) 
    120             self.current_dataset.dx = dxvals 
     106            error_message += "Not all data points could be loaded.\n" 
     107            correctly_loaded = False 
    121108        if self.current_dataset.x.size != self.current_dataset.y.size: 
    122             self.errors.add("The x and y data sets are not the same size.") 
     109            error_message += "The x and y data sets are not the same size.\n" 
     110            correctly_loaded = False 
    123111        if self.current_dataset.y.size != self.current_dataset.dy.size: 
    124             self.errors.add("The y and dy datasets are not the same size.") 
    125         self.current_dataset.errors = self.errors 
     112            error_message += "The y and dy datasets are not the same size.\n" 
     113            correctly_loaded = False 
     114 
    126115        self.current_dataset.xaxis("Q", q_unit) 
    127116        self.current_dataset.yaxis("Intensity", i_unit) 
    128117        xml_intermediate = self.raw_data[self.upper:] 
    129118        xml = ''.join(xml_intermediate) 
    130         self.set_xml_string(xml) 
    131         dom = self.xmlroot.xpath('/fileinfo') 
    132         self._parse_child(dom) 
    133         self.output.append(self.current_dataset) 
     119        try: 
     120            self.set_xml_string(xml) 
     121            dom = self.xmlroot.xpath('/fileinfo') 
     122            self._parse_child(dom) 
     123        except Exception as e: 
     124            # Data loaded but XML metadata has an error 
     125            error_message += "Data points have been loaded but there was an " 
     126            error_message += "error reading XML metadata: " + e.message 
     127            correctly_loaded = False 
     128        self.send_to_output() 
     129        if not correctly_loaded: 
     130            raise DataReaderException(error_message) 
    134131 
    135132    def _parse_child(self, dom, parent=''): 
     
    146143                self._parse_child(node, key) 
    147144                if key == "SampleDetector": 
    148                     self.current_dataset.detector.append(self.detector) 
     145                    self.current_datainfo.detector.append(self.detector) 
    149146                    self.detector = Detector() 
    150147            else: 
    151148                if key == "value": 
    152149                    if parent == "Wavelength": 
    153                         self.current_dataset.source.wavelength = value 
     150                        self.current_datainfo.source.wavelength = value 
    154151                    elif parent == "SampleDetector": 
    155152                        self.detector.distance = value 
    156153                    elif parent == "Temperature": 
    157                         self.current_dataset.sample.temperature = value 
     154                        self.current_datainfo.sample.temperature = value 
    158155                    elif parent == "CounterSlitLength": 
    159156                        self.detector.slit_length = value 
     
    161158                    value = value.replace("_", "") 
    162159                    if parent == "Wavelength": 
    163                         self.current_dataset.source.wavelength_unit = value 
     160                        self.current_datainfo.source.wavelength_unit = value 
    164161                    elif parent == "SampleDetector": 
    165162                        self.detector.distance_unit = value 
     
    169166                        self.current_dataset.yaxis(self.current_dataset._yaxis, value) 
    170167                    elif parent == "Temperature": 
    171                         self.current_dataset.sample.temperature_unit = value 
     168                        self.current_datainfo.sample.temperature_unit = value 
    172169                    elif parent == "CounterSlitLength": 
    173170                        self.detector.slit_length_unit = value 
  • src/sas/sascalc/dataloader/readers/ascii_reader.py

    r235f514 rf994e8b1  
    11""" 
    2     ASCII reader 
     2    Generic multi-column ASCII data reader 
    33""" 
    44############################################################################ 
    5 #This software was developed by the University of Tennessee as part of the 
    6 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation.  
    8 #If you use DANSE applications to do scientific research that leads to 
    9 #publication, we ask that you acknowledge the use of the software with the 
    10 #following sentence: 
    11 #This work benefited from DANSE software developed under NSF award DMR-0520547. 
    12 #copyright 2008, University of Tennessee 
     5# This software was developed by the University of Tennessee as part of the 
     6# Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
     7# project funded by the US National Science Foundation. 
     8# If you use DANSE applications to do scientific research that leads to 
     9# publication, we ask that you acknowledge the use of the software with the 
     10# following sentence: 
     11# This work benefited from DANSE software developed under NSF award DMR-0520547. 
     12# copyright 2008, University of Tennessee 
    1313############################################################################# 
    1414 
     15import logging 
     16from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     17from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D 
     18from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\ 
     19    DefaultReaderException 
    1520 
    16 import numpy as np 
    17 import os 
    18 from sas.sascalc.dataloader.data_info import Data1D 
    19  
    20 # Check whether we have a converter available 
    21 has_converter = True 
    22 try: 
    23     from sas.sascalc.data_util.nxsunit import Converter 
    24 except: 
    25     has_converter = False 
    26 _ZERO = 1e-16 
     21logger = logging.getLogger(__name__) 
    2722 
    2823 
    29 class Reader: 
     24class Reader(FileReader): 
    3025    """ 
    3126    Class to load ascii files (2, 3 or 4 columns). 
    3227    """ 
    33     ## File type 
     28    # File type 
    3429    type_name = "ASCII" 
    35  
    36     ## Wildcards 
     30    # Wildcards 
    3731    type = ["ASCII files (*.txt)|*.txt", 
    3832            "ASCII files (*.dat)|*.dat", 
    3933            "ASCII files (*.abs)|*.abs", 
    4034            "CSV files (*.csv)|*.csv"] 
    41     ## List of allowed extensions 
    42     ext = ['.txt', '.TXT', '.dat', '.DAT', '.abs', '.ABS', 'csv', 'CSV'] 
     35    # List of allowed extensions 
     36    ext = ['.txt', '.dat', '.abs', '.csv'] 
     37    # Flag to bypass extension check 
     38    allow_all = True 
     39    # data unless that is the only data 
     40    min_data_pts = 5 
    4341 
    44     ## Flag to bypass extension check 
    45     allow_all = True 
     42    def get_file_contents(self): 
     43        """ 
     44        Get the contents of the file 
     45        """ 
    4646 
    47     def read(self, path): 
    48         """ 
    49         Load data file 
     47        buff = self.f_open.read() 
     48        filepath = self.f_open.name 
     49        lines = buff.splitlines() 
     50        self.output = [] 
     51        self.current_datainfo = DataInfo() 
     52        self.current_datainfo.filename = filepath 
     53        self.reset_data_list(len(lines)) 
    5054 
    51         :param path: file path 
    52         :return: Data1D object, or None 
     55        # The first good line of data will define whether 
     56        # we have 2-column or 3-column ascii 
     57        has_error_dx = None 
     58        has_error_dy = None 
    5359 
    54         :raise RuntimeError: when the file can't be opened 
    55         :raise ValueError: when the length of the data vectors are inconsistent 
    56         """ 
    57         if os.path.isfile(path): 
    58             basename = os.path.basename(path) 
    59             _, extension = os.path.splitext(basename) 
    60             if self.allow_all or extension.lower() in self.ext: 
    61                 try: 
    62                     # Read in binary mode since GRASP frequently has no-ascii 
    63                     # characters that breaks the open operation 
    64                     input_f = open(path,'rb') 
    65                 except: 
    66                     raise  RuntimeError, "ascii_reader: cannot open %s" % path 
    67                 buff = input_f.read() 
    68                 lines = buff.splitlines() 
     60        # Initialize counters for data lines and header lines. 
     61        is_data = False 
     62        # More than "5" lines of data is considered as actual 
     63        # To count # of current data candidate lines 
     64        candidate_lines = 0 
     65        # To count total # of previous data candidate lines 
     66        candidate_lines_previous = 0 
     67        # Current line number 
     68        line_no = 0 
     69        # minimum required number of columns of data 
     70        lentoks = 2 
     71        for line in lines: 
     72            toks = self.splitline(line.strip()) 
     73            # To remember the number of columns in the current line of data 
     74            new_lentoks = len(toks) 
     75            try: 
     76                if new_lentoks == 0: 
     77                    # If the line is blank, skip and continue on 
     78                    # In case of breaks within data sets. 
     79                    continue 
     80                elif new_lentoks != lentoks and is_data: 
     81                    # If a footer is found, break the loop and save the data 
     82                    break 
     83                elif new_lentoks != lentoks and not is_data: 
     84                    # If header lines are numerical 
     85                    candidate_lines = 0 
     86                    self.reset_data_list(len(lines) - line_no) 
    6987 
    70                 # Arrays for data storage 
    71                 tx = np.zeros(0) 
    72                 ty = np.zeros(0) 
    73                 tdy = np.zeros(0) 
    74                 tdx = np.zeros(0) 
     88                self.current_dataset.x[candidate_lines] = float(toks[0]) 
    7589 
    76                 # The first good line of data will define whether 
    77                 # we have 2-column or 3-column ascii 
     90                if new_lentoks > 1: 
     91                    self.current_dataset.y[candidate_lines] = float(toks[1]) 
     92 
     93                # If a 3rd row is present, consider it dy 
     94                if new_lentoks > 2: 
     95                    self.current_dataset.dy[candidate_lines] = \ 
     96                        float(toks[2]) 
     97                    has_error_dy = True 
     98 
     99                # If a 4th row is present, consider it dx 
     100                if new_lentoks > 3: 
     101                    self.current_dataset.dx[candidate_lines] = \ 
     102                        float(toks[3]) 
     103                    has_error_dx = True 
     104 
     105                candidate_lines += 1 
     106                # If 5 or more lines, this is considering the set data 
     107                if candidate_lines >= self.min_data_pts: 
     108                    is_data = True 
     109 
     110                if is_data and new_lentoks >= 8: 
     111                    msg = "This data looks like 2D ASCII data. Use the file " 
     112                    msg += "converter tool to convert it to NXcanSAS." 
     113                    raise FileContentsException(msg) 
     114 
     115                # To remember the # of columns on the current line 
     116                # for the next line of data 
     117                lentoks = new_lentoks 
     118                line_no += 1 
     119            except ValueError: 
     120                # ValueError is raised when non numeric strings conv. to float 
     121                # It is data and meet non - number, then stop reading 
     122                if is_data: 
     123                    break 
     124                # Delete the previously stored lines of data candidates if 
     125                # the list is not data 
     126                self.reset_data_list(len(lines) - line_no) 
     127                lentoks = 2 
    78128                has_error_dx = None 
    79129                has_error_dy = None 
     130                # Reset # of lines of data candidates 
     131                candidate_lines = 0 
     132         
     133        if not is_data: 
     134            self.set_all_to_none() 
     135            if self.extension in self.ext: 
     136                msg = "ASCII Reader error: Fewer than five Q data points found " 
     137                msg += "in {}.".format(filepath) 
     138                raise FileContentsException(msg) 
     139            else: 
     140                msg = "ASCII Reader could not load the file {}".format(filepath) 
     141                raise DefaultReaderException(msg) 
     142        # Sanity check 
     143        if has_error_dy and not len(self.current_dataset.y) == \ 
     144                len(self.current_dataset.dy): 
     145            msg = "ASCII Reader error: Number of I and dI data points are" 
     146            msg += " different in {}.".format(filepath) 
     147            # TODO: Add error to self.current_datainfo.errors instead? 
     148            self.set_all_to_none() 
     149            raise FileContentsException(msg) 
     150        if has_error_dx and not len(self.current_dataset.x) == \ 
     151                len(self.current_dataset.dx): 
     152            msg = "ASCII Reader error: Number of Q and dQ data points are" 
     153            msg += " different in {}.".format(filepath) 
     154            # TODO: Add error to self.current_datainfo.errors instead? 
     155            self.set_all_to_none() 
     156            raise FileContentsException(msg) 
    80157 
    81                 #Initialize counters for data lines and header lines. 
    82                 is_data = False 
    83                 # More than "5" lines of data is considered as actual 
    84                 # data unless that is the only data 
    85                 min_data_pts = 5 
    86                 # To count # of current data candidate lines 
    87                 candidate_lines = 0 
    88                 # To count total # of previous data candidate lines 
    89                 candidate_lines_previous = 0 
    90                 #minimum required number of columns of data 
    91                 lentoks = 2 
    92                 for line in lines: 
    93                     toks = self.splitline(line) 
    94                     # To remember the # of columns in the current line of data 
    95                     new_lentoks = len(toks) 
    96                     try: 
    97                         if new_lentoks == 1 and not is_data: 
    98                             ## If only one item in list, no longer data 
    99                             raise ValueError 
    100                         elif new_lentoks == 0: 
    101                             ## If the line is blank, skip and continue on 
    102                             ## In case of breaks within data sets. 
    103                             continue 
    104                         elif new_lentoks != lentoks and is_data: 
    105                             ## If a footer is found, break the loop and save the data 
    106                             break 
    107                         elif new_lentoks != lentoks and not is_data: 
    108                             ## If header lines are numerical 
    109                             candidate_lines = 0 
    110                             candidate_lines_previous = 0 
     158        self.remove_empty_q_values(has_error_dx, has_error_dy) 
     159        self.current_dataset.xaxis("\\rm{Q}", 'A^{-1}') 
     160        self.current_dataset.yaxis("\\rm{Intensity}", "cm^{-1}") 
    111161 
    112                         #Make sure that all columns are numbers. 
    113                         for colnum in range(len(toks)): 
    114                             # Any non-floating point values throw ValueError 
    115                             float(toks[colnum]) 
    116  
    117                         candidate_lines += 1 
    118                         _x = float(toks[0]) 
    119                         _y = float(toks[1]) 
    120                         _dx = None 
    121                         _dy = None 
    122  
    123                         #If 5 or more lines, this is considering the set data 
    124                         if candidate_lines >= min_data_pts: 
    125                             is_data = True 
    126  
    127                         # If a 3rd row is present, consider it dy 
    128                         if new_lentoks > 2: 
    129                             _dy = float(toks[2]) 
    130                         has_error_dy = False if _dy is None else True 
    131  
    132                         # If a 4th row is present, consider it dx 
    133                         if new_lentoks > 3: 
    134                             _dx = float(toks[3]) 
    135                         has_error_dx = False if _dx is None else True 
    136  
    137                         # Delete the previously stored lines of data candidates if 
    138                         # the list is not data 
    139                         if candidate_lines == 1 and -1 < candidate_lines_previous < min_data_pts and \ 
    140                             is_data == False: 
    141                             try: 
    142                                 tx = np.zeros(0) 
    143                                 ty = np.zeros(0) 
    144                                 tdy = np.zeros(0) 
    145                                 tdx = np.zeros(0) 
    146                             except: 
    147                                 pass 
    148  
    149                         if has_error_dy == True: 
    150                             tdy = np.append(tdy, _dy) 
    151                         if has_error_dx == True: 
    152                             tdx = np.append(tdx, _dx) 
    153                         tx = np.append(tx, _x) 
    154                         ty = np.append(ty, _y) 
    155  
    156                         #To remember the # of columns on the current line 
    157                         # for the next line of data 
    158                         lentoks = new_lentoks 
    159                         candidate_lines_previous = candidate_lines 
    160                     except ValueError: 
    161                         # It is data and meet non - number, then stop reading 
    162                         if is_data == True: 
    163                             break 
    164                         lentoks = 2 
    165                         has_error_dx = None 
    166                         has_error_dy = None 
    167                         #Reset # of lines of data candidates 
    168                         candidate_lines = 0 
    169                     except: 
    170                         pass 
    171  
    172                 input_f.close() 
    173                 if not is_data: 
    174                     msg = "ascii_reader: x has no data" 
    175                     raise RuntimeError, msg 
    176                 # Sanity check 
    177                 if has_error_dy == True and not len(ty) == len(tdy): 
    178                     msg = "ascii_reader: y and dy have different length" 
    179                     raise RuntimeError, msg 
    180                 if has_error_dx == True and not len(tx) == len(tdx): 
    181                     msg = "ascii_reader: y and dy have different length" 
    182                     raise RuntimeError, msg 
    183                 # If the data length is zero, consider this as 
    184                 # though we were not able to read the file. 
    185                 if len(tx) == 0: 
    186                     raise RuntimeError, "ascii_reader: could not load file" 
    187  
    188                 #Let's re-order the data to make cal. 
    189                 # curve look better some cases 
    190                 ind = np.lexsort((ty, tx)) 
    191                 x = np.zeros(len(tx)) 
    192                 y = np.zeros(len(ty)) 
    193                 dy = np.zeros(len(tdy)) 
    194                 dx = np.zeros(len(tdx)) 
    195                 output = Data1D(x, y, dy=dy, dx=dx) 
    196                 self.filename = output.filename = basename 
    197  
    198                 for i in ind: 
    199                     x[i] = tx[ind[i]] 
    200                     y[i] = ty[ind[i]] 
    201                     if has_error_dy == True: 
    202                         dy[i] = tdy[ind[i]] 
    203                     if has_error_dx == True: 
    204                         dx[i] = tdx[ind[i]] 
    205                 # Zeros in dx, dy 
    206                 if has_error_dx: 
    207                     dx[dx == 0] = _ZERO 
    208                 if has_error_dy: 
    209                     dy[dy == 0] = _ZERO 
    210                 #Data 
    211                 output.x = x[x != 0] 
    212                 output.y = y[x != 0] 
    213                 output.dy = dy[x != 0] if has_error_dy == True\ 
    214                     else np.zeros(len(output.y)) 
    215                 output.dx = dx[x != 0] if has_error_dx == True\ 
    216                     else np.zeros(len(output.x)) 
    217  
    218                 output.xaxis("\\rm{Q}", 'A^{-1}') 
    219                 output.yaxis("\\rm{Intensity}", "cm^{-1}") 
    220  
    221                 # Store loading process information 
    222                 output.meta_data['loader'] = self.type_name 
    223                 if len(output.x) < 1: 
    224                     raise RuntimeError, "%s is empty" % path 
    225                 return output 
    226  
    227         else: 
    228             raise RuntimeError, "%s is not a file" % path 
    229         return None 
    230  
    231     def splitline(self, line): 
    232         """ 
    233         Splits a line into pieces based on common delimeters 
    234         :param line: A single line of text 
    235         :return: list of values 
    236         """ 
    237         # Initial try for CSV (split on ,) 
    238         toks = line.split(',') 
    239         # Now try SCSV (split on ;) 
    240         if len(toks) < 2: 
    241             toks = line.split(';') 
    242         # Now go for whitespace 
    243         if len(toks) < 2: 
    244             toks = line.split() 
    245         return toks 
     162        # Store loading process information 
     163        self.current_datainfo.meta_data['loader'] = self.type_name 
     164        self.send_to_output() 
  • src/sas/sascalc/dataloader/readers/associations.py

    ra1b8fee rce8c7bd  
    1414#copyright 2009, University of Tennessee 
    1515############################################################################# 
    16 from __future__ import print_function 
    17  
    18 import os 
    1916import sys 
    2017import logging 
    21 import json 
    2218 
    2319logger = logging.getLogger(__name__) 
    2420 
    25 FILE_NAME = 'defaults.json' 
     21FILE_ASSOCIATIONS = { 
     22    ".xml": "cansas_reader", 
     23    ".ses": "sesans_reader", 
     24    ".h5": "cansas_reader_HDF5", 
     25    ".txt": "ascii_reader", 
     26    ".dat": "red2d_reader", 
     27    ".abs": "abs_reader", 
     28    ".sans": "danse_reader", 
     29    ".pdh": "anton_paar_saxs_reader" 
     30} 
    2631 
    27 def read_associations(loader, settings=FILE_NAME): 
     32 
     33def read_associations(loader, settings=FILE_ASSOCIATIONS): 
    2834    """ 
    2935    Read the specified settings file to associate 
    3036    default readers to file extension. 
    31      
     37 
    3238    :param loader: Loader object 
    3339    :param settings: path to the json settings file [string] 
    3440    """ 
    35     reader_dir = os.path.dirname(__file__) 
    36     path = os.path.join(reader_dir, settings) 
    37      
    38     # If we can't find the file in the installation 
    39     # directory, look into the execution directory. 
    40     if not os.path.isfile(path): 
    41         path = os.path.join(os.getcwd(), settings) 
    42     if not os.path.isfile(path): 
    43         path = os.path.join(sys.path[0], settings) 
    44     if not os.path.isfile(path): 
    45         path = settings 
    46     if not os.path.isfile(path): 
    47         path = "./%s" % settings 
    48     if os.path.isfile(path): 
    49         with open(path) as fh: 
    50             json_tree = json.load(fh) 
    51          
    52         # Read in the file extension associations 
    53         entry_list = json_tree['SasLoader']['FileType'] 
    54  
    55         # For each FileType entry, get the associated reader and extension 
    56         for entry in entry_list: 
    57             reader = entry['-reader'] 
    58             ext = entry['-extension'] 
    59              
    60             if reader is not None and ext is not None: 
    61                 # Associate the extension with a particular reader 
    62                 # TODO: Modify the Register code to be case-insensitive 
    63                 # and remove the extra line below. 
    64                 try: 
    65                     exec "import %s" % reader 
    66                     exec "loader.associate_file_type('%s', %s)" % (ext.lower(), 
    67                                                                     reader) 
    68                     exec "loader.associate_file_type('%s', %s)" % (ext.upper(), 
    69                                                                     reader) 
    70                 except: 
    71                     msg = "read_associations: skipping association" 
    72                     msg += " for %s\n  %s" % (ext.lower(), sys.exc_value) 
    73                     logger.error(msg) 
    74     else: 
    75         print("Could not find reader association settings\n  %s [%s]" % (__file__, os.getcwd())) 
    76           
    77           
    78 def register_readers(registry_function): 
    79     """ 
    80     Function called by the registry/loader object to register 
    81     all default readers using a call back function. 
    82      
    83     :WARNING: this method is now obsolete 
    84  
    85     :param registry_function: function to be called to register each reader 
    86     """ 
    87     logger.info("register_readers is now obsolete: use read_associations()") 
    88     import abs_reader 
    89     import ascii_reader 
    90     import cansas_reader 
    91     import danse_reader 
    92     import hfir1d_reader 
    93     import IgorReader 
    94     import red2d_reader 
    95     #import tiff_reader 
    96     import nexus_reader 
    97     import sesans_reader 
    98     import cansas_reader_HDF5 
    99     import anton_paar_saxs_reader 
    100     registry_function(sesans_reader) 
    101     registry_function(abs_reader) 
    102     registry_function(ascii_reader) 
    103     registry_function(cansas_reader) 
    104     registry_function(danse_reader) 
    105     registry_function(hfir1d_reader) 
    106     registry_function(IgorReader) 
    107     registry_function(red2d_reader) 
    108     #registry_function(tiff_reader) 
    109     registry_function(nexus_reader) 
    110     registry_function(cansas_reader_HDF5) 
    111     registry_function(anton_paar_saxs_reader) 
    112     return True 
     41    # For each FileType entry, get the associated reader and extension 
     42    for ext, reader in settings.iteritems(): 
     43        if reader is not None and ext is not None: 
     44            # Associate the extension with a particular reader 
     45            # TODO: Modify the Register code to be case-insensitive 
     46            # FIXME: Remove exec statements 
     47            # and remove the extra line below. 
     48            try: 
     49                exec "import %s" % reader 
     50                exec "loader.associate_file_type('%s', %s)" % (ext.lower(), 
     51                                                                reader) 
     52                exec "loader.associate_file_type('%s', %s)" % (ext.upper(), 
     53                                                                reader) 
     54            except: 
     55                msg = "read_associations: skipping association" 
     56                msg += " for %s\n  %s" % (ext.lower(), sys.exc_value) 
     57                logger.error(msg) 
  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    r7432acb ra78a02f  
    1 """ 
    2     CanSAS data reader - new recursive cansas_version. 
    3 """ 
    4 ############################################################################ 
    5 #This software was developed by the University of Tennessee as part of the 
    6 #Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation. 
    8 #If you use DANSE applications to do scientific research that leads to 
    9 #publication, we ask that you acknowledge the use of the software with the 
    10 #following sentence: 
    11 #This work benefited from DANSE software developed under NSF award DMR-0520547. 
    12 #copyright 2008,2009 University of Tennessee 
    13 ############################################################################# 
    14  
    151import logging 
    162import numpy as np 
     
    2915from sas.sascalc.dataloader.readers.xml_reader import XMLreader 
    3016from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants, CurrentLevel 
     17from sas.sascalc.dataloader.loader_exceptions import FileContentsException, \ 
     18    DefaultReaderException, DataReaderException 
    3119 
    3220# The following 2 imports *ARE* used. Do not remove either. 
    3321import xml.dom.minidom 
    3422from xml.dom.minidom import parseString 
     23 
     24from lxml import etree 
    3525 
    3626logger = logging.getLogger(__name__) 
     
    5545 
    5646class Reader(XMLreader): 
    57     """ 
    58     Class to load cansas 1D XML files 
    59  
    60     :Dependencies: 
    61         The CanSAS reader requires PyXML 0.8.4 or later. 
    62     """ 
    63     # CanSAS version - defaults to version 1.0 
    6447    cansas_version = "1.0" 
    6548    base_ns = "{cansas1d/1.0}" 
     
    7558    ns_list = None 
    7659    # Temporary storage location for loading multiple data sets in a single file 
    77     current_datainfo = None 
    78     current_dataset = None 
    7960    current_data1d = None 
    8061    data = None 
    81     # List of data1D objects to be sent back to SasView 
    82     output = None 
    8362    # Wildcards 
    8463    type = ["XML files (*.xml)|*.xml", "SasView Save Files (*.svs)|*.svs"] 
     
    11089 
    11190    def read(self, xml_file, schema_path="", invalid=True): 
    112         """ 
    113         Validate and read in an xml_file file in the canSAS format. 
    114  
    115         :param xml_file: A canSAS file path in proper XML format 
    116         :param schema_path: A file path to an XML schema to validate the xml_file against 
    117         """ 
    118         # For every file loaded, reset everything to a base state 
     91        if schema_path != "" or invalid != True: 
     92            # read has been called from self.get_file_contents because xml file doens't conform to schema 
     93            _, self.extension = os.path.splitext(os.path.basename(xml_file)) 
     94            return self.get_file_contents(xml_file=xml_file, schema_path=schema_path, invalid=invalid) 
     95 
     96        # Otherwise, read has been called by the data loader - file_reader_base_class handles this 
     97        return super(XMLreader, self).read(xml_file) 
     98 
     99    def get_file_contents(self, xml_file=None, schema_path="", invalid=True): 
     100        # Reset everything since we're loading a new file 
    119101        self.reset_state() 
    120102        self.invalid = invalid 
    121         # Check that the file exists 
    122         if os.path.isfile(xml_file): 
    123             basename, extension = os.path.splitext(os.path.basename(xml_file)) 
    124             # If the file type is not allowed, return nothing 
    125             if extension in self.ext or self.allow_all: 
    126                 # Get the file location of 
    127                 self.load_file_and_schema(xml_file, schema_path) 
    128                 self.add_data_set() 
    129                 # Try to load the file, but raise an error if unable to. 
    130                 # Check the file matches the XML schema 
     103        if xml_file is None: 
     104            xml_file = self.f_open.name 
     105        # We don't sure f_open since lxml handles opnening/closing files 
     106        if not self.f_open.closed: 
     107            self.f_open.close() 
     108 
     109        basename, _ = os.path.splitext(os.path.basename(xml_file)) 
     110 
     111        try: 
     112            # Raises FileContentsException 
     113            self.load_file_and_schema(xml_file, schema_path) 
     114            self.current_datainfo = DataInfo() 
     115            # Raises FileContentsException if file doesn't meet CanSAS schema 
     116            self.is_cansas(self.extension) 
     117            self.invalid = False # If we reach this point then file must be valid CanSAS 
     118 
     119            # Parse each SASentry 
     120            entry_list = self.xmlroot.xpath('/ns:SASroot/ns:SASentry', namespaces={ 
     121                'ns': self.cansas_defaults.get("ns") 
     122            }) 
     123            # Look for a SASentry 
     124            self.names.append("SASentry") 
     125            self.set_processing_instructions() 
     126 
     127            for entry in entry_list: 
     128                self.current_datainfo.filename = basename + self.extension 
     129                self.current_datainfo.meta_data["loader"] = "CanSAS XML 1D" 
     130                self.current_datainfo.meta_data[PREPROCESS] = self.processing_instructions 
     131                self._parse_entry(entry) 
     132                has_error_dx = self.current_dataset.dx is not None 
     133                has_error_dy = self.current_dataset.dy is not None 
     134                self.remove_empty_q_values(has_error_dx=has_error_dx, 
     135                    has_error_dy=has_error_dy) 
     136                self.send_to_output() # Combine datasets with DataInfo 
     137                self.current_datainfo = DataInfo() # Reset DataInfo 
     138        except FileContentsException as fc_exc: 
     139            # File doesn't meet schema - try loading with a less strict schema 
     140            base_name = xml_reader.__file__ 
     141            base_name = base_name.replace("\\", "/") 
     142            base = base_name.split("/sas/")[0] 
     143            if self.cansas_version == "1.1": 
     144                invalid_schema = INVALID_SCHEMA_PATH_1_1.format(base, self.cansas_defaults.get("schema")) 
     145            else: 
     146                invalid_schema = INVALID_SCHEMA_PATH_1_0.format(base, self.cansas_defaults.get("schema")) 
     147            self.set_schema(invalid_schema) 
     148            if self.invalid: 
    131149                try: 
    132                     self.is_cansas(extension) 
    133                     self.invalid = False 
    134                     # Get each SASentry from XML file and add it to a list. 
    135                     entry_list = self.xmlroot.xpath( 
    136                             '/ns:SASroot/ns:SASentry', 
    137                             namespaces={'ns': self.cansas_defaults.get("ns")}) 
    138                     self.names.append("SASentry") 
    139  
    140                     # Get all preprocessing events and encoding 
    141                     self.set_processing_instructions() 
    142  
    143                     # Parse each <SASentry> item 
    144                     for entry in entry_list: 
    145                         # Create a new DataInfo object for every <SASentry> 
    146  
    147                         # Set the file name and then parse the entry. 
    148                         self.current_datainfo.filename = basename + extension 
    149                         self.current_datainfo.meta_data["loader"] = "CanSAS XML 1D" 
    150                         self.current_datainfo.meta_data[PREPROCESS] = \ 
    151                             self.processing_instructions 
    152  
    153                         # Parse the XML SASentry 
    154                         self._parse_entry(entry) 
    155                         # Combine datasets with datainfo 
    156                         self.add_data_set() 
    157                 except RuntimeError: 
    158                     # If the file does not match the schema, raise this error 
     150                    # Load data with less strict schema 
     151                    self.read(xml_file, invalid_schema, False) 
     152 
     153                    # File can still be read but doesn't match schema, so raise exception 
     154                    self.load_file_and_schema(xml_file) # Reload strict schema so we can find where error are in file 
    159155                    invalid_xml = self.find_invalid_xml() 
    160                     invalid_xml = INVALID_XML.format(basename + extension) + invalid_xml 
    161                     self.errors.add(invalid_xml) 
    162                     # Try again with an invalid CanSAS schema, that requires only a data set in each 
    163                     base_name = xml_reader.__file__ 
    164                     base_name = base_name.replace("\\", "/") 
    165                     base = base_name.split("/sas/")[0] 
    166                     if self.cansas_version == "1.1": 
    167                         invalid_schema = INVALID_SCHEMA_PATH_1_1.format(base, self.cansas_defaults.get("schema")) 
    168                     else: 
    169                         invalid_schema = INVALID_SCHEMA_PATH_1_0.format(base, self.cansas_defaults.get("schema")) 
    170                     self.set_schema(invalid_schema) 
    171                     try: 
    172                         if self.invalid: 
    173                             if self.is_cansas(): 
    174                                 self.output = self.read(xml_file, invalid_schema, False) 
    175                             else: 
    176                                 raise RuntimeError 
    177                         else: 
    178                             raise RuntimeError 
    179                     except RuntimeError: 
    180                         x = np.zeros(1) 
    181                         y = np.zeros(1) 
    182                         self.current_data1d = Data1D(x,y) 
    183                         self.current_data1d.errors = self.errors 
    184                         return [self.current_data1d] 
    185         else: 
    186             self.output.append("Not a valid file path.") 
    187         # Return a list of parsed entries that dataloader can manage 
    188         return self.output 
     156                    invalid_xml = INVALID_XML.format(basename + self.extension) + invalid_xml 
     157                    raise DataReaderException(invalid_xml) # Handled by base class 
     158                except FileContentsException as fc_exc: 
     159                    msg = "CanSAS Reader could not load the file {}".format(xml_file) 
     160                    if fc_exc.message is not None: # Propagate error messages from earlier 
     161                        msg = fc_exc.message 
     162                    if not self.extension in self.ext: # If the file has no associated loader 
     163                        raise DefaultReaderException(msg) 
     164                    raise FileContentsException(msg) 
     165                    pass 
     166            else: 
     167                raise fc_exc 
     168        except Exception as e: # Convert all other exceptions to FileContentsExceptions 
     169            raise FileContentsException(e.message) 
     170 
     171 
     172    def load_file_and_schema(self, xml_file, schema_path=""): 
     173        base_name = xml_reader.__file__ 
     174        base_name = base_name.replace("\\", "/") 
     175        base = base_name.split("/sas/")[0] 
     176 
     177        # Try and parse the XML file 
     178        try: 
     179            self.set_xml_file(xml_file) 
     180        except etree.XMLSyntaxError: # File isn't valid XML so can't be loaded 
     181            msg = "SasView cannot load {}.\nInvalid XML syntax".format(xml_file) 
     182            raise FileContentsException(msg) 
     183 
     184        self.cansas_version = self.xmlroot.get("version", "1.0") 
     185        self.cansas_defaults = CANSAS_NS.get(self.cansas_version, "1.0") 
     186 
     187        if schema_path == "": 
     188            schema_path = "{}/sas/sascalc/dataloader/readers/schema/{}".format( 
     189                base, self.cansas_defaults.get("schema").replace("\\", "/") 
     190            ) 
     191        self.set_schema(schema_path) 
     192 
     193    def is_cansas(self, ext="xml"): 
     194        """ 
     195        Checks to see if the XML file is a CanSAS file 
     196 
     197        :param ext: The file extension of the data file 
     198        :raises FileContentsException: Raised if XML file isn't valid CanSAS 
     199        """ 
     200        if self.validate_xml(): # Check file is valid XML 
     201            name = "{http://www.w3.org/2001/XMLSchema-instance}schemaLocation" 
     202            value = self.xmlroot.get(name) 
     203            # Check schema CanSAS version matches file CanSAS version 
     204            if CANSAS_NS.get(self.cansas_version).get("ns") == value.rsplit(" ")[0]: 
     205                return True 
     206        if ext == "svs": 
     207            return True # Why is this required? 
     208        # If we get to this point then file isn't valid CanSAS 
     209        logger.warning("File doesn't meet CanSAS schema. Trying to load anyway.") 
     210        raise FileContentsException("The file is not valid CanSAS") 
    189211 
    190212    def _parse_entry(self, dom, recurse=False): 
    191         """ 
    192         Parse a SASEntry - new recursive method for parsing the dom of 
    193             the CanSAS data format. This will allow multiple data files 
    194             and extra nodes to be read in simultaneously. 
    195  
    196         :param dom: dom object with a namespace base of names 
    197         """ 
    198  
    199213        if not self._is_call_local() and not recurse: 
    200214            self.reset_state() 
    201             self.add_data_set() 
     215            self.data = [] 
     216            self.current_datainfo = DataInfo() 
    202217            self.names.append("SASentry") 
    203218            self.parent_class = "SASentry" 
    204         self._check_for_empty_data() 
    205         self.base_ns = "{0}{1}{2}".format("{", \ 
    206                             CANSAS_NS.get(self.cansas_version).get("ns"), "}") 
    207  
    208         # Go through each child in the parent element 
     219        # Create an empty dataset if no data has been passed to the reader 
     220        if self.current_dataset is None: 
     221            self.current_dataset = plottable_1D(np.empty(0), np.empty(0), 
     222                np.empty(0), np.empty(0)) 
     223        self.base_ns = "{" + CANSAS_NS.get(self.cansas_version).get("ns") + "}" 
     224 
     225        # Loop through each child in the parent element 
    209226        for node in dom: 
    210227            attr = node.attrib 
     
    217234            if tagname == "fitting_plug_in" or tagname == "pr_inversion" or tagname == "invariant": 
    218235                continue 
    219  
    220236            # Get where to store content 
    221237            self.names.append(tagname_original) 
     
    233249                        else: 
    234250                            self.current_dataset.shape = () 
    235                 # Recursion step to access data within the group 
    236                 self._parse_entry(node, True) 
     251                # Recurse to access data within the group 
     252                self._parse_entry(node, recurse=True) 
    237253                if tagname == "SASsample": 
    238254                    self.current_datainfo.sample.name = name 
     
    244260                    self.aperture.name = name 
    245261                    self.aperture.type = type 
    246                 self.add_intermediate() 
     262                self._add_intermediate() 
    247263            else: 
    248264                if isinstance(self.current_dataset, plottable_2D): 
     
    261277                    self.current_datainfo.notes.append(data_point) 
    262278 
    263                 # I and Q - 1D data 
     279                # I and Q points 
    264280                elif tagname == 'I' and isinstance(self.current_dataset, plottable_1D): 
    265281                    unit_list = unit.split("|") 
     
    283299                    self.current_dataset.dx = np.append(self.current_dataset.dx, data_point) 
    284300                elif tagname == 'dQw': 
     301                    if self.current_dataset.dxw is None: 
     302                        self.current_dataset.dxw = np.empty(0) 
    285303                    self.current_dataset.dxw = np.append(self.current_dataset.dxw, data_point) 
    286304                elif tagname == 'dQl': 
     305                    if self.current_dataset.dxl is None: 
     306                        self.current_dataset.dxl = np.empty(0) 
    287307                    self.current_dataset.dxl = np.append(self.current_dataset.dxl, data_point) 
    288308                elif tagname == 'Qmean': 
     
    356376                elif tagname == 'name' and self.parent_class == 'SASinstrument': 
    357377                    self.current_datainfo.instrument = data_point 
     378 
    358379                # Detector Information 
    359380                elif tagname == 'name' and self.parent_class == 'SASdetector': 
     
    401422                    self.detector.orientation.z = data_point 
    402423                    self.detector.orientation_unit = unit 
     424 
    403425                # Collimation and Aperture 
    404426                elif tagname == 'length' and self.parent_class == 'SAScollimation': 
     
    434456                elif tagname == 'term' and self.parent_class == 'SASprocess': 
    435457                    unit = attr.get("unit", "") 
    436                     dic = {} 
    437                     dic["name"] = name 
    438                     dic["value"] = data_point 
    439                     dic["unit"] = unit 
     458                    dic = { "name": name, "value": data_point, "unit": unit } 
    440459                    self.process.term.append(dic) 
    441460 
     
    490509        if not self._is_call_local() and not recurse: 
    491510            self.frm = "" 
    492             self.add_data_set() 
     511            self.current_datainfo.errors = set() 
     512            for error in self.errors: 
     513                self.current_datainfo.errors.add(error) 
     514            self.errors.clear() 
     515            self.send_to_output() 
    493516            empty = None 
    494517            return self.output[0], empty 
    495518 
    496  
    497519    def _is_call_local(self): 
    498         """ 
    499  
    500         """ 
    501520        if self.frm == "": 
    502521            inter = inspect.stack() 
     
    510529        return True 
    511530 
    512     def is_cansas(self, ext="xml"): 
    513         """ 
    514         Checks to see if the xml file is a CanSAS file 
    515  
    516         :param ext: The file extension of the data file 
    517         """ 
    518         if self.validate_xml(): 
    519             name = "{http://www.w3.org/2001/XMLSchema-instance}schemaLocation" 
    520             value = self.xmlroot.get(name) 
    521             if CANSAS_NS.get(self.cansas_version).get("ns") == \ 
    522                     value.rsplit(" ")[0]: 
    523                 return True 
    524         if ext == "svs": 
    525             return True 
    526         raise RuntimeError 
    527  
    528     def load_file_and_schema(self, xml_file, schema_path=""): 
    529         """ 
    530         Loads the file and associates a schema, if a schema is passed in or if one already exists 
    531  
    532         :param xml_file: The xml file path sent to Reader.read 
    533         :param schema_path: The path to a schema associated with the xml_file, or find one based on the file 
    534         """ 
    535         base_name = xml_reader.__file__ 
    536         base_name = base_name.replace("\\", "/") 
    537         base = base_name.split("/sas/")[0] 
    538  
    539         # Load in xml file and get the cansas version from the header 
    540         self.set_xml_file(xml_file) 
    541         self.cansas_version = self.xmlroot.get("version", "1.0") 
    542  
    543         # Generic values for the cansas file based on the version 
    544         self.cansas_defaults = CANSAS_NS.get(self.cansas_version, "1.0") 
    545         if schema_path == "": 
    546             schema_path = "{0}/sas/sascalc/dataloader/readers/schema/{1}".format \ 
    547                 (base, self.cansas_defaults.get("schema")).replace("\\", "/") 
    548  
    549         # Link a schema to the XML file. 
    550         self.set_schema(schema_path) 
    551  
    552     def add_data_set(self): 
    553         """ 
    554         Adds the current_dataset to the list of outputs after preforming final processing on the data and then calls a 
    555         private method to generate a new data set. 
    556  
    557         :param key: NeXus group name for current tree level 
    558         """ 
    559  
    560         if self.current_datainfo and self.current_dataset: 
    561             self._final_cleanup() 
    562         self.data = [] 
    563         self.current_datainfo = DataInfo() 
    564  
    565     def _initialize_new_data_set(self, node=None): 
    566         """ 
    567         A private class method to generate a new 1D data object. 
    568         Outside methods should call add_data_set() to be sure any existing data is stored properly. 
    569  
    570         :param node: XML node to determine if 1D or 2D data 
    571         """ 
    572         x = np.array(0) 
    573         y = np.array(0) 
    574         for child in node: 
    575             if child.tag.replace(self.base_ns, "") == "Idata": 
    576                 for i_child in child: 
    577                     if i_child.tag.replace(self.base_ns, "") == "Qx": 
    578                         self.current_dataset = plottable_2D() 
    579                         return 
    580         self.current_dataset = plottable_1D(x, y) 
    581  
    582     def add_intermediate(self): 
     531    def _add_intermediate(self): 
    583532        """ 
    584533        This method stores any intermediate objects within the final data set after fully reading the set. 
    585  
    586         :param parent: The NXclass name for the h5py Group object that just finished being processed 
    587         """ 
    588  
     534        """ 
    589535        if self.parent_class == 'SASprocess': 
    590536            self.current_datainfo.process.append(self.process) 
     
    605551            self._check_for_empty_resolution() 
    606552            self.data.append(self.current_dataset) 
    607  
    608     def _final_cleanup(self): 
    609         """ 
    610         Final cleanup of the Data1D object to be sure it has all the 
    611         appropriate information needed for perspectives 
    612         """ 
    613  
    614         # Append errors to dataset and reset class errors 
    615         self.current_datainfo.errors = set() 
    616         for error in self.errors: 
    617             self.current_datainfo.errors.add(error) 
    618         self.errors.clear() 
    619  
    620         # Combine all plottables with datainfo and append each to output 
    621         # Type cast data arrays to float64 and find min/max as appropriate 
    622         for dataset in self.data: 
    623             if isinstance(dataset, plottable_1D): 
    624                 if dataset.x is not None: 
    625                     dataset.x = np.delete(dataset.x, [0]) 
    626                     dataset.x = dataset.x.astype(np.float64) 
    627                     dataset.xmin = np.min(dataset.x) 
    628                     dataset.xmax = np.max(dataset.x) 
    629                 if dataset.y is not None: 
    630                     dataset.y = np.delete(dataset.y, [0]) 
    631                     dataset.y = dataset.y.astype(np.float64) 
    632                     dataset.ymin = np.min(dataset.y) 
    633                     dataset.ymax = np.max(dataset.y) 
    634                 if dataset.dx is not None: 
    635                     dataset.dx = np.delete(dataset.dx, [0]) 
    636                     dataset.dx = dataset.dx.astype(np.float64) 
    637                 if dataset.dxl is not None: 
    638                     dataset.dxl = np.delete(dataset.dxl, [0]) 
    639                     dataset.dxl = dataset.dxl.astype(np.float64) 
    640                 if dataset.dxw is not None: 
    641                     dataset.dxw = np.delete(dataset.dxw, [0]) 
    642                     dataset.dxw = dataset.dxw.astype(np.float64) 
    643                 if dataset.dy is not None: 
    644                     dataset.dy = np.delete(dataset.dy, [0]) 
    645                     dataset.dy = dataset.dy.astype(np.float64) 
    646                 np.trim_zeros(dataset.x) 
    647                 np.trim_zeros(dataset.y) 
    648                 np.trim_zeros(dataset.dy) 
    649             elif isinstance(dataset, plottable_2D): 
    650                 dataset.data = dataset.data.astype(np.float64) 
    651                 dataset.qx_data = dataset.qx_data.astype(np.float64) 
    652                 dataset.xmin = np.min(dataset.qx_data) 
    653                 dataset.xmax = np.max(dataset.qx_data) 
    654                 dataset.qy_data = dataset.qy_data.astype(np.float64) 
    655                 dataset.ymin = np.min(dataset.qy_data) 
    656                 dataset.ymax = np.max(dataset.qy_data) 
    657                 dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data 
    658                                          + dataset.qy_data * dataset.qy_data) 
    659                 if dataset.err_data is not None: 
    660                     dataset.err_data = dataset.err_data.astype(np.float64) 
    661                 if dataset.dqx_data is not None: 
    662                     dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
    663                 if dataset.dqy_data is not None: 
    664                     dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
    665                 if dataset.mask is not None: 
    666                     dataset.mask = dataset.mask.astype(dtype=bool) 
    667  
    668                 if len(dataset.shape) == 2: 
    669                     n_rows, n_cols = dataset.shape 
    670                     dataset.y_bins = dataset.qy_data[0::int(n_cols)] 
    671                     dataset.x_bins = dataset.qx_data[:int(n_cols)] 
    672                     dataset.data = dataset.data.flatten() 
    673                 else: 
    674                     dataset.y_bins = [] 
    675                     dataset.x_bins = [] 
    676                     dataset.data = dataset.data.flatten() 
    677  
    678             final_dataset = combine_data(dataset, self.current_datainfo) 
    679             self.output.append(final_dataset) 
    680  
    681     def _create_unique_key(self, dictionary, name, numb=0): 
    682         """ 
    683         Create a unique key value for any dictionary to prevent overwriting 
    684         Recurse until a unique key value is found. 
    685  
    686         :param dictionary: A dictionary with any number of entries 
    687         :param name: The index of the item to be added to dictionary 
    688         :param numb: The number to be appended to the name, starts at 0 
    689         """ 
    690         if dictionary.get(name) is not None: 
    691             numb += 1 
    692             name = name.split("_")[0] 
    693             name += "_{0}".format(numb) 
    694             name = self._create_unique_key(dictionary, name, numb) 
    695         return name 
    696553 
    697554    def _get_node_value(self, node, tagname): 
     
    801658        return node_value, value_unit 
    802659 
    803     def _check_for_empty_data(self): 
    804         """ 
    805         Creates an empty data set if no data is passed to the reader 
    806  
    807         :param data1d: presumably a Data1D object 
    808         """ 
    809         if self.current_dataset is None: 
    810             x_vals = np.empty(0) 
    811             y_vals = np.empty(0) 
    812             dx_vals = np.empty(0) 
    813             dy_vals = np.empty(0) 
    814             dxl = np.empty(0) 
    815             dxw = np.empty(0) 
    816             self.current_dataset = plottable_1D(x_vals, y_vals, dx_vals, dy_vals) 
    817             self.current_dataset.dxl = dxl 
    818             self.current_dataset.dxw = dxw 
    819  
    820660    def _check_for_empty_resolution(self): 
    821661        """ 
    822         A method to check all resolution data sets are the same size as I and Q 
    823         """ 
    824         if isinstance(self.current_dataset, plottable_1D): 
    825             dql_exists = False 
    826             dqw_exists = False 
    827             dq_exists = False 
    828             di_exists = False 
    829             if self.current_dataset.dxl is not None: 
    830                 dql_exists = True 
    831             if self.current_dataset.dxw is not None: 
    832                 dqw_exists = True 
    833             if self.current_dataset.dx is not None: 
    834                 dq_exists = True 
    835             if self.current_dataset.dy is not None: 
    836                 di_exists = True 
    837             if dqw_exists and not dql_exists: 
    838                 array_size = self.current_dataset.dxw.size - 1 
    839                 self.current_dataset.dxl = np.append(self.current_dataset.dxl, 
    840                                                      np.zeros([array_size])) 
    841             elif dql_exists and not dqw_exists: 
    842                 array_size = self.current_dataset.dxl.size - 1 
    843                 self.current_dataset.dxw = np.append(self.current_dataset.dxw, 
    844                                                      np.zeros([array_size])) 
    845             elif not dql_exists and not dqw_exists and not dq_exists: 
    846                 array_size = self.current_dataset.x.size - 1 
    847                 self.current_dataset.dx = np.append(self.current_dataset.dx, 
    848                                                     np.zeros([array_size])) 
    849             if not di_exists: 
    850                 array_size = self.current_dataset.y.size - 1 
    851                 self.current_dataset.dy = np.append(self.current_dataset.dy, 
    852                                                     np.zeros([array_size])) 
    853         elif isinstance(self.current_dataset, plottable_2D): 
    854             dqx_exists = False 
    855             dqy_exists = False 
    856             di_exists = False 
    857             mask_exists = False 
    858             if self.current_dataset.dqx_data is not None: 
    859                 dqx_exists = True 
    860             if self.current_dataset.dqy_data is not None: 
    861                 dqy_exists = True 
    862             if self.current_dataset.err_data is not None: 
    863                 di_exists = True 
    864             if self.current_dataset.mask is not None: 
    865                 mask_exists = True 
    866             if not dqy_exists: 
    867                 array_size = self.current_dataset.qy_data.size - 1 
    868                 self.current_dataset.dqy_data = np.append( 
    869                     self.current_dataset.dqy_data, np.zeros([array_size])) 
    870             if not dqx_exists: 
    871                 array_size = self.current_dataset.qx_data.size - 1 
    872                 self.current_dataset.dqx_data = np.append( 
    873                     self.current_dataset.dqx_data, np.zeros([array_size])) 
    874             if not di_exists: 
    875                 array_size = self.current_dataset.data.size - 1 
    876                 self.current_dataset.err_data = np.append( 
    877                     self.current_dataset.err_data, np.zeros([array_size])) 
    878             if not mask_exists: 
    879                 array_size = self.current_dataset.data.size - 1 
    880                 self.current_dataset.mask = np.append( 
    881                     self.current_dataset.mask, 
    882                     np.ones([array_size] ,dtype=bool)) 
    883  
    884     ####### All methods below are for writing CanSAS XML files ####### 
    885  
     662        a method to check all resolution data sets are the same size as I and q 
     663        """ 
     664        dql_exists = False 
     665        dqw_exists = False 
     666        dq_exists = False 
     667        di_exists = False 
     668        if self.current_dataset.dxl is not None: 
     669            dql_exists = True 
     670        if self.current_dataset.dxw is not None: 
     671            dqw_exists = True 
     672        if self.current_dataset.dx is not None: 
     673            dq_exists = True 
     674        if self.current_dataset.dy is not None: 
     675            di_exists = True 
     676        if dqw_exists and not dql_exists: 
     677            array_size = self.current_dataset.dxw.size - 1 
     678            self.current_dataset.dxl = np.append(self.current_dataset.dxl, 
     679                                                 np.zeros([array_size])) 
     680        elif dql_exists and not dqw_exists: 
     681            array_size = self.current_dataset.dxl.size - 1 
     682            self.current_dataset.dxw = np.append(self.current_dataset.dxw, 
     683                                                 np.zeros([array_size])) 
     684        elif not dql_exists and not dqw_exists and not dq_exists: 
     685            array_size = self.current_dataset.x.size - 1 
     686            self.current_dataset.dx = np.append(self.current_dataset.dx, 
     687                                                np.zeros([array_size])) 
     688        if not di_exists: 
     689            array_size = self.current_dataset.y.size - 1 
     690            self.current_dataset.dy = np.append(self.current_dataset.dy, 
     691                                                np.zeros([array_size])) 
     692 
     693    def _initialize_new_data_set(self, node=None): 
     694        if node is not None: 
     695            for child in node: 
     696                if child.tag.replace(self.base_ns, "") == "Idata": 
     697                    for i_child in child: 
     698                        if i_child.tag.replace(self.base_ns, "") == "Qx": 
     699                            self.current_dataset = plottable_2D() 
     700                            return 
     701        self.current_dataset = plottable_1D(np.array(0), np.array(0)) 
     702 
     703    ## Writing Methods 
    886704    def write(self, filename, datainfo): 
    887705        """ 
     
    15141332            exec "storage.%s = entry.text.strip()" % variable 
    15151333 
    1516  
    15171334# DO NOT REMOVE Called by outside packages: 
    15181335#    sas.sasgui.perspectives.invariant.invariant_state 
  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    rc94280c rdcb91cf  
    1313    TransmissionSpectrum, Detector 
    1414from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable 
    15  
    16  
    17 class Reader(): 
     15from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DefaultReaderException 
     16from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     17 
     18 
     19class Reader(FileReader): 
    1820    """ 
    1921    A class for reading in CanSAS v2.0 data files. The existing iteration opens 
     
    4042    # Raw file contents to be processed 
    4143    raw_data = None 
    42     # Data info currently being read in 
    43     current_datainfo = None 
    44     # SASdata set currently being read in 
    45     current_dataset = None 
    4644    # List of plottable1D objects that should be linked to the current_datainfo 
    4745    data1d = None 
     
    5654    # Flag to bypass extension check 
    5755    allow_all = True 
    58     # List of files to return 
    59     output = None 
    60  
    61     def read(self, filename): 
     56 
     57    def get_file_contents(self): 
    6258        """ 
    6359        This is the general read method that all SasView data_loaders must have. 
     
    6864        # Reinitialize when loading a new data file to reset all class variables 
    6965        self.reset_class_variables() 
     66 
     67        filename = self.f_open.name 
     68        self.f_open.close() # IO handled by h5py 
     69 
    7070        # Check that the file exists 
    7171        if os.path.isfile(filename): 
     
    7575            if extension in self.ext or self.allow_all: 
    7676                # Load the data file 
    77                 self.raw_data = h5py.File(filename, 'r') 
    78                 # Read in all child elements of top level SASroot 
    79                 self.read_children(self.raw_data, []) 
    80                 # Add the last data set to the list of outputs 
    81                 self.add_data_set() 
    82                 # Close the data file 
    83                 self.raw_data.close() 
    84         # Return data set(s) 
    85         return self.output 
     77                try: 
     78                    self.raw_data = h5py.File(filename, 'r') 
     79                except Exception as e: 
     80                    if extension not in self.ext: 
     81                        msg = "CanSAS2.0 HDF5 Reader could not load file {}".format(basename + extension) 
     82                        raise DefaultReaderException(msg) 
     83                    raise FileContentsException(e.message) 
     84                try: 
     85                    # Read in all child elements of top level SASroot 
     86                    self.read_children(self.raw_data, []) 
     87                    # Add the last data set to the list of outputs 
     88                    self.add_data_set() 
     89                except Exception as exc: 
     90                    raise FileContentsException(exc.message) 
     91                finally: 
     92                    # Close the data file 
     93                    self.raw_data.close() 
     94 
     95                for dataset in self.output: 
     96                    if isinstance(dataset, Data1D): 
     97                        if dataset.x.size < 5: 
     98                            self.output = [] 
     99                            raise FileContentsException("Fewer than 5 data points found.") 
    86100 
    87101    def reset_class_variables(self): 
     
    427441        Data1D and Data2D objects 
    428442        """ 
    429  
    430443        # Type cast data arrays to float64 
    431444        if len(self.current_datainfo.trans_spectrum) > 0: 
     
    451464        # Type cast data arrays to float64 and find min/max as appropriate 
    452465        for dataset in self.data2d: 
    453             dataset.data = dataset.data.astype(np.float64) 
    454             dataset.err_data = dataset.err_data.astype(np.float64) 
    455             if dataset.qx_data is not None: 
    456                 dataset.xmin = np.min(dataset.qx_data) 
    457                 dataset.xmax = np.max(dataset.qx_data) 
    458                 dataset.qx_data = dataset.qx_data.astype(np.float64) 
    459             if dataset.dqx_data is not None: 
    460                 dataset.dqx_data = dataset.dqx_data.astype(np.float64) 
    461             if dataset.qy_data is not None: 
    462                 dataset.ymin = np.min(dataset.qy_data) 
    463                 dataset.ymax = np.max(dataset.qy_data) 
    464                 dataset.qy_data = dataset.qy_data.astype(np.float64) 
    465             if dataset.dqy_data is not None: 
    466                 dataset.dqy_data = dataset.dqy_data.astype(np.float64) 
    467             if dataset.q_data is not None: 
    468                 dataset.q_data = dataset.q_data.astype(np.float64) 
    469466            zeros = np.ones(dataset.data.size, dtype=bool) 
    470467            try: 
     
    489486                dataset.x_bins = dataset.qx_data[:n_cols] 
    490487                dataset.data = dataset.data.flatten() 
    491  
    492             final_dataset = combine_data_info_with_plottable( 
    493                 dataset, self.current_datainfo) 
    494             self.output.append(final_dataset) 
     488            self.current_dataset = dataset 
     489            self.send_to_output() 
    495490 
    496491        for dataset in self.data1d: 
    497             if dataset.x is not None: 
    498                 dataset.x = dataset.x.astype(np.float64) 
    499                 dataset.xmin = np.min(dataset.x) 
    500                 dataset.xmax = np.max(dataset.x) 
    501             if dataset.y is not None: 
    502                 dataset.y = dataset.y.astype(np.float64) 
    503                 dataset.ymin = np.min(dataset.y) 
    504                 dataset.ymax = np.max(dataset.y) 
    505             if dataset.dx is not None: 
    506                 dataset.dx = dataset.dx.astype(np.float64) 
    507             if dataset.dxl is not None: 
    508                 dataset.dxl = dataset.dxl.astype(np.float64) 
    509             if dataset.dxw is not None: 
    510                 dataset.dxw = dataset.dxw.astype(np.float64) 
    511             if dataset.dy is not None: 
    512                 dataset.dy = dataset.dy.astype(np.float64) 
    513             final_dataset = combine_data_info_with_plottable( 
    514                 dataset, self.current_datainfo) 
    515             self.output.append(final_dataset) 
     492            self.current_dataset = dataset 
     493            self.send_to_output() 
    516494 
    517495    def add_data_set(self, key=""): 
  • src/sas/sascalc/dataloader/readers/danse_reader.py

    r235f514 ra78a02f  
    55#This software was developed by the University of Tennessee as part of the 
    66#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation.  
     7#project funded by the US National Science Foundation. 
    88#If you use DANSE applications to do scientific research that leads to 
    99#publication, we ask that you acknowledge the use of the software with the 
     
    1414import math 
    1515import os 
    16 import sys 
    1716import numpy as np 
    1817import logging 
    19 from sas.sascalc.dataloader.data_info import Data2D, Detector 
     18from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector 
    2019from sas.sascalc.dataloader.manipulations import reader2D_converter 
     20from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     21from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
    2122 
    2223logger = logging.getLogger(__name__) 
     
    3031 
    3132 
    32 class Reader: 
     33class Reader(FileReader): 
    3334    """ 
    3435    Example data manipulation 
     
    4041    ## Extension 
    4142    ext  = ['.sans', '.SANS'] 
    42          
    43     def read(self, filename=None): 
    44         """ 
    45         Open and read the data in a file 
    46         @param file: path of the file 
    47         """ 
    48          
    49         read_it = False 
    50         for item in self.ext: 
    51             if filename.lower().find(item) >= 0: 
    52                 read_it = True 
    53                  
    54         if read_it: 
     43 
     44    def get_file_contents(self): 
     45        self.current_datainfo = DataInfo() 
     46        self.current_dataset = plottable_2D() 
     47        self.output = [] 
     48 
     49        loaded_correctly = True 
     50        error_message = "" 
     51 
     52        # defaults 
     53        # wavelength in Angstrom 
     54        wavelength = 10.0 
     55        # Distance in meter 
     56        distance   = 11.0 
     57        # Pixel number of center in x 
     58        center_x   = 65 
     59        # Pixel number of center in y 
     60        center_y   = 65 
     61        # Pixel size [mm] 
     62        pixel      = 5.0 
     63        # Size in x, in pixels 
     64        size_x     = 128 
     65        # Size in y, in pixels 
     66        size_y     = 128 
     67        # Format version 
     68        fversion   = 1.0 
     69 
     70        self.current_datainfo.filename = os.path.basename(self.f_open.name) 
     71        detector = Detector() 
     72        self.current_datainfo.detector.append(detector) 
     73 
     74        self.current_dataset.data = np.zeros([size_x, size_y]) 
     75        self.current_dataset.err_data = np.zeros([size_x, size_y]) 
     76 
     77        read_on = True 
     78        data_start_line = 1 
     79        while read_on: 
     80            line = self.f_open.readline() 
     81            data_start_line += 1 
     82            if line.find("DATA:") >= 0: 
     83                read_on = False 
     84                break 
     85            toks = line.split(':') 
    5586            try: 
    56                 datafile = open(filename, 'r') 
    57             except: 
    58                 raise  RuntimeError,"danse_reader cannot open %s" % (filename) 
    59          
    60             # defaults 
    61             # wavelength in Angstrom 
    62             wavelength = 10.0 
    63             # Distance in meter 
    64             distance   = 11.0 
    65             # Pixel number of center in x 
    66             center_x   = 65 
    67             # Pixel number of center in y 
    68             center_y   = 65 
    69             # Pixel size [mm] 
    70             pixel      = 5.0 
    71             # Size in x, in pixels 
    72             size_x     = 128 
    73             # Size in y, in pixels 
    74             size_y     = 128 
    75             # Format version 
    76             fversion   = 1.0 
    77              
    78             output = Data2D() 
    79             output.filename = os.path.basename(filename) 
    80             detector = Detector() 
    81             output.detector.append(detector) 
    82              
    83             output.data = np.zeros([size_x,size_y]) 
    84             output.err_data = np.zeros([size_x, size_y]) 
    85              
    86             data_conv_q = None 
    87             data_conv_i = None 
    88              
    89             if has_converter == True and output.Q_unit != '1/A': 
    90                 data_conv_q = Converter('1/A') 
    91                 # Test it 
    92                 data_conv_q(1.0, output.Q_unit) 
    93                  
    94             if has_converter == True and output.I_unit != '1/cm': 
    95                 data_conv_i = Converter('1/cm') 
    96                 # Test it 
    97                 data_conv_i(1.0, output.I_unit) 
    98          
    99             read_on = True 
    100             while read_on: 
    101                 line = datafile.readline() 
    102                 if line.find("DATA:") >= 0: 
    103                     read_on = False 
    104                     break 
    105                 toks = line.split(':') 
    10687                if toks[0] == "FORMATVERSION": 
    10788                    fversion = float(toks[1]) 
    108                 if toks[0] == "WAVELENGTH": 
     89                elif toks[0] == "WAVELENGTH": 
    10990                    wavelength = float(toks[1]) 
    11091                elif toks[0] == "DISTANCE": 
     
    120101                elif toks[0] == "SIZE_Y": 
    121102                    size_y = int(toks[1]) 
    122              
    123             # Read the data 
    124             data = [] 
    125             error = [] 
    126             if fversion == 1.0: 
    127                 data_str = datafile.readline() 
    128                 data = data_str.split(' ') 
    129             else: 
    130                 read_on = True 
    131                 while read_on: 
    132                     data_str = datafile.readline() 
    133                     if len(data_str) == 0: 
    134                         read_on = False 
    135                     else: 
    136                         toks = data_str.split() 
    137                         try: 
    138                             val = float(toks[0]) 
    139                             err = float(toks[1]) 
    140                             if data_conv_i is not None: 
    141                                 val = data_conv_i(val, units=output._yunit) 
    142                                 err = data_conv_i(err, units=output._yunit) 
    143                             data.append(val) 
    144                             error.append(err) 
    145                         except: 
    146                             logger.info("Skipping line:%s,%s" %(data_str, 
    147                                                                 sys.exc_value)) 
    148              
    149             # Initialize 
    150             x_vals = [] 
    151             y_vals = [] 
    152             ymin = None 
    153             ymax = None 
    154             xmin = None 
    155             xmax = None 
    156              
    157             # Qx and Qy vectors 
    158             theta = pixel / distance / 100.0 
    159             stepq = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
    160             for i_x in range(size_x): 
    161                 theta = (i_x - center_x + 1) * pixel / distance / 100.0 
    162                 qx = 4.0 * math.pi / wavelength * math.sin(theta / 2.0) 
    163                  
    164                 if has_converter == True and output.Q_unit != '1/A': 
    165                     qx = data_conv_q(qx, units=output.Q_unit) 
    166                  
    167                 x_vals.append(qx) 
    168                 if xmin is None or qx < xmin: 
    169                     xmin = qx 
    170                 if xmax is None or qx > xmax: 
    171                     xmax = qx 
    172              
    173             ymin = None 
    174             ymax = None 
    175             for i_y in range(size_y): 
    176                 theta = (i_y - center_y + 1) * pixel / distance / 100.0 
    177                 qy = 4.0 * math.pi / wavelength * math.sin(theta/2.0) 
    178                  
    179                 if has_converter == True and output.Q_unit != '1/A': 
    180                     qy = data_conv_q(qy, units=output.Q_unit) 
    181                  
    182                 y_vals.append(qy) 
    183                 if ymin is None or qy < ymin: 
    184                     ymin = qy 
    185                 if ymax is None or qy > ymax: 
    186                     ymax = qy 
    187              
    188             # Store the data in the 2D array 
    189             i_x = 0 
    190             i_y = -1 
    191              
    192             for i_pt in range(len(data)): 
    193                 try: 
    194                     value = float(data[i_pt]) 
    195                 except: 
    196                     # For version 1.0, the data were still 
    197                     # stored as strings at this point. 
    198                     msg = "Skipping entry (v1.0):%s,%s" % (str(data[i_pt]), 
    199                                                            sys.exc_value) 
    200                     logger.info(msg) 
    201                  
    202                 # Get bin number 
    203                 if math.fmod(i_pt, size_x) == 0: 
    204                     i_x = 0 
    205                     i_y += 1 
    206                 else: 
    207                     i_x += 1 
    208                      
    209                 output.data[i_y][i_x] = value 
    210                 if fversion>1.0: 
    211                     output.err_data[i_y][i_x] = error[i_pt] 
    212                  
    213             # Store all data 
    214             # Store wavelength 
    215             if has_converter == True and output.source.wavelength_unit != 'A': 
    216                 conv = Converter('A') 
    217                 wavelength = conv(wavelength, 
    218                                   units=output.source.wavelength_unit) 
    219             output.source.wavelength = wavelength 
    220                  
    221             # Store distance 
    222             if has_converter == True and detector.distance_unit != 'm': 
    223                 conv = Converter('m') 
    224                 distance = conv(distance, units=detector.distance_unit) 
    225             detector.distance = distance 
    226              
    227             # Store pixel size 
    228             if has_converter == True and detector.pixel_size_unit != 'mm': 
    229                 conv = Converter('mm') 
    230                 pixel = conv(pixel, units=detector.pixel_size_unit) 
    231             detector.pixel_size.x = pixel 
    232             detector.pixel_size.y = pixel 
    233  
    234             # Store beam center in distance units 
    235             detector.beam_center.x = center_x * pixel 
    236             detector.beam_center.y = center_y * pixel 
    237              
    238             # Store limits of the image (2D array) 
    239             xmin = xmin - stepq / 2.0 
    240             xmax = xmax + stepq / 2.0 
    241             ymin = ymin - stepq /2.0 
    242             ymax = ymax + stepq / 2.0 
    243              
    244             if has_converter == True and output.Q_unit != '1/A': 
    245                 xmin = data_conv_q(xmin, units=output.Q_unit) 
    246                 xmax = data_conv_q(xmax, units=output.Q_unit) 
    247                 ymin = data_conv_q(ymin, units=output.Q_unit) 
    248                 ymax = data_conv_q(ymax, units=output.Q_unit) 
    249             output.xmin = xmin 
    250             output.xmax = xmax 
    251             output.ymin = ymin 
    252             output.ymax = ymax 
    253              
    254             # Store x and y axis bin centers 
    255             output.x_bins = x_vals 
    256             output.y_bins = y_vals 
    257             
    258             # Units 
    259             if data_conv_q is not None: 
    260                 output.xaxis("\\rm{Q_{x}}", output.Q_unit) 
    261                 output.yaxis("\\rm{Q_{y}}", output.Q_unit) 
    262             else: 
    263                 output.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
    264                 output.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
    265                  
    266             if data_conv_i is not None: 
    267                 output.zaxis("\\rm{Intensity}", output.I_unit) 
    268             else: 
    269                 output.zaxis("\\rm{Intensity}", "cm^{-1}") 
    270             
    271             if not fversion >= 1.0: 
    272                 msg = "Danse_reader can't read this file %s" % filename 
    273                 raise ValueError, msg 
    274             else: 
    275                 logger.info("Danse_reader Reading %s \n" % filename) 
    276              
    277             # Store loading process information 
    278             output.meta_data['loader'] = self.type_name 
    279             output = reader2D_converter(output) 
    280             return output 
    281          
    282         return None 
     103            except ValueError as e: 
     104                error_message += "Unable to parse {}. Default value used.\n".format(toks[0]) 
     105                loaded_correctly = False 
     106 
     107        # Read the data 
     108        data = [] 
     109        error = [] 
     110        if not fversion >= 1.0: 
     111            msg = "danse_reader can't read this file {}".format(self.f_open.name) 
     112            raise FileContentsException(msg) 
     113 
     114        for line_num, data_str in enumerate(self.f_open.readlines()): 
     115            toks = data_str.split() 
     116            try: 
     117                val = float(toks[0]) 
     118                err = float(toks[1]) 
     119                data.append(val) 
     120                error.append(err) 
     121            except ValueError as exc: 
     122                msg = "Unable to parse line {}: {}".format(line_num + data_start_line, data_str.strip()) 
     123                raise FileContentsException(msg) 
     124 
     125        num_pts = size_x * size_y 
     126        if len(data) < num_pts: 
     127            msg = "Not enough data points provided. Expected {} but got {}".format( 
     128                size_x * size_y, len(data)) 
     129            raise FileContentsException(msg) 
     130        elif len(data) > num_pts: 
     131            error_message += ("Too many data points provided. Expected {0} but" 
     132                " got {1}. Only the first {0} will be used.\n").format(num_pts, len(data)) 
     133            loaded_correctly = False 
     134            data = data[:num_pts] 
     135            error = error[:num_pts] 
     136 
     137        # Qx and Qy vectors 
     138        theta = pixel / distance / 100.0 
     139        i_x = np.arange(size_x) 
     140        theta = (i_x - center_x + 1) * pixel / distance / 100.0 
     141        x_vals = 4.0 * np.pi / wavelength * np.sin(theta / 2.0) 
     142        xmin = x_vals.min() 
     143        xmax = x_vals.max() 
     144 
     145        i_y = np.arange(size_y) 
     146        theta = (i_y - center_y + 1) * pixel / distance / 100.0 
     147        y_vals = 4.0 * np.pi / wavelength * np.sin(theta / 2.0) 
     148        ymin = y_vals.min() 
     149        ymax = y_vals.max() 
     150 
     151        self.current_dataset.data = np.array(data, dtype=np.float64).reshape((size_y, size_x)) 
     152        if fversion > 1.0: 
     153            self.current_dataset.err_data = np.array(error, dtype=np.float64).reshape((size_y, size_x)) 
     154 
     155        # Store all data 
     156        # Store wavelength 
     157        if has_converter == True and self.current_datainfo.source.wavelength_unit != 'A': 
     158            conv = Converter('A') 
     159            wavelength = conv(wavelength, 
     160                              units=self.current_datainfo.source.wavelength_unit) 
     161        self.current_datainfo.source.wavelength = wavelength 
     162 
     163        # Store distance 
     164        if has_converter == True and detector.distance_unit != 'm': 
     165            conv = Converter('m') 
     166            distance = conv(distance, units=detector.distance_unit) 
     167        detector.distance = distance 
     168 
     169        # Store pixel size 
     170        if has_converter == True and detector.pixel_size_unit != 'mm': 
     171            conv = Converter('mm') 
     172            pixel = conv(pixel, units=detector.pixel_size_unit) 
     173        detector.pixel_size.x = pixel 
     174        detector.pixel_size.y = pixel 
     175 
     176        # Store beam center in distance units 
     177        detector.beam_center.x = center_x * pixel 
     178        detector.beam_center.y = center_y * pixel 
     179 
     180 
     181        self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
     182        self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
     183        self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 
     184 
     185        self.current_dataset.x_bins = x_vals 
     186        self.current_dataset.y_bins = y_vals 
     187 
     188        # Reshape data 
     189        x_vals = np.tile(x_vals, (size_y, 1)).flatten() 
     190        y_vals = np.tile(y_vals, (size_x, 1)).T.flatten() 
     191        if (np.all(self.current_dataset.err_data == None) 
     192                or np.any(self.current_dataset.err_data <= 0)): 
     193            new_err_data = np.sqrt(np.abs(self.current_dataset.data)) 
     194        else: 
     195            new_err_data = self.current_dataset.err_data.flatten() 
     196 
     197        self.current_dataset.err_data = new_err_data 
     198        self.current_dataset.qx_data = x_vals 
     199        self.current_dataset.qy_data = y_vals 
     200        self.current_dataset.q_data = np.sqrt(x_vals**2 + y_vals**2) 
     201        self.current_dataset.mask = np.ones(len(x_vals), dtype=bool) 
     202 
     203        # Store loading process information 
     204        self.current_datainfo.meta_data['loader'] = self.type_name 
     205 
     206        self.send_to_output() 
     207 
     208        if not loaded_correctly: 
     209            raise DataReaderException(error_message) 
  • src/sas/sascalc/dataloader/readers/red2d_reader.py

    ra1b8fee r2f85af7  
    55#This software was developed by the University of Tennessee as part of the 
    66#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation.  
     7#project funded by the US National Science Foundation. 
    88#See the license text in license.txt 
    99#copyright 2008, University of Tennessee 
    1010###################################################################### 
    11 from __future__ import print_function 
    12  
    1311import os 
    1412import numpy as np 
    1513import math 
    16 from sas.sascalc.dataloader.data_info import Data2D, Detector 
     14from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector 
     15from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     16from sas.sascalc.dataloader.loader_exceptions import FileContentsException 
    1717 
    1818# Look for unit converter 
     
    2222except: 
    2323    has_converter = False 
    24      
    25      
     24 
     25 
    2626def check_point(x_point): 
    2727    """ 
     
    3333    except: 
    3434        return 0 
    35        
    36          
    37 class Reader: 
     35 
     36 
     37class Reader(FileReader): 
    3838    """ Simple data reader for Igor data files """ 
    3939    ## File type 
     
    4343    ## Extension 
    4444    ext = ['.DAT', '.dat'] 
    45      
     45 
    4646    def write(self, filename, data): 
    4747        """ 
    4848        Write to .dat 
    49          
     49 
    5050        :param filename: file name to write 
    5151        :param data: data2D 
     
    5353        import time 
    5454        # Write the file 
    55         fd = open(filename, 'w') 
    56         t = time.localtime() 
    57         time_str = time.strftime("%H:%M on %b %d %y", t) 
    58          
    59         header_str = "Data columns are Qx - Qy - I(Qx,Qy)\n\nASCII data" 
    60         header_str += " created at %s \n\n" % time_str 
    61         # simple 2D header 
    62         fd.write(header_str) 
    63         # write qx qy I values 
    64         for i in range(len(data.data)): 
    65             fd.write("%g  %g  %g\n" % (data.qx_data[i], 
    66                                         data.qy_data[i], 
    67                                        data.data[i])) 
    68         # close 
    69         fd.close() 
    70  
    71     def read(self, filename=None): 
    72         """ Read file """ 
    73         if not os.path.isfile(filename): 
    74             raise ValueError, \ 
    75             "Specified file %s is not a regular file" % filename 
    76  
     55        try: 
     56            fd = open(filename, 'w') 
     57            t = time.localtime() 
     58            time_str = time.strftime("%H:%M on %b %d %y", t) 
     59 
     60            header_str = "Data columns are Qx - Qy - I(Qx,Qy)\n\nASCII data" 
     61            header_str += " created at %s \n\n" % time_str 
     62            # simple 2D header 
     63            fd.write(header_str) 
     64            # write qx qy I values 
     65            for i in range(len(data.data)): 
     66                fd.write("%g  %g  %g\n" % (data.qx_data[i], 
     67                                            data.qy_data[i], 
     68                                           data.data[i])) 
     69        finally: 
     70            fd.close() 
     71 
     72    def get_file_contents(self): 
    7773        # Read file 
    78         f = open(filename, 'r') 
    79         buf = f.read() 
    80         f.close() 
     74        buf = self.f_open.read() 
     75        self.f_open.close() 
    8176        # Instantiate data object 
    82         output = Data2D() 
    83         output.filename = os.path.basename(filename) 
    84         detector = Detector() 
    85         if len(output.detector) > 0: 
    86             print(str(output.detector[0])) 
    87         output.detector.append(detector) 
    88                  
     77        self.current_dataset = plottable_2D() 
     78        self.current_datainfo = DataInfo() 
     79        self.current_datainfo.filename = os.path.basename(self.f_open.name) 
     80        self.current_datainfo.detector.append(Detector()) 
     81 
    8982        # Get content 
    90         dataStarted = False 
    91          
     83        data_started = False 
     84 
    9285        ## Defaults 
    9386        lines = buf.split('\n') 
    9487        x = [] 
    9588        y = [] 
    96          
     89 
    9790        wavelength = None 
    9891        distance = None 
    9992        transmission = None 
    100          
     93 
    10194        pixel_x = None 
    10295        pixel_y = None 
    103          
    104         isInfo = False 
    105         isCenter = False 
    106  
    107         data_conv_q = None 
    108         data_conv_i = None 
    109          
    110         # Set units: This is the unit assumed for Q and I in the data file. 
    111         if has_converter == True and output.Q_unit != '1/A': 
    112             data_conv_q = Converter('1/A') 
    113             # Test it 
    114             data_conv_q(1.0, output.Q_unit) 
    115              
    116         if has_converter == True and output.I_unit != '1/cm': 
    117             data_conv_i = Converter('1/cm') 
    118             # Test it 
    119             data_conv_i(1.0, output.I_unit) 
    120          
    121                
     96 
     97        is_info = False 
     98        is_center = False 
     99 
    122100        # Remove the last lines before the for loop if the lines are empty 
    123101        # to calculate the exact number of data points 
     
    135113            ## Reading the header applies only to IGOR/NIST 2D q_map data files 
    136114            # Find setup info line 
    137             if isInfo: 
    138                 isInfo = False 
     115            if is_info: 
     116                is_info = False 
    139117                line_toks = line.split() 
    140118                # Wavelength in Angstrom 
     
    143121                    # Units 
    144122                    if has_converter == True and \ 
    145                     output.source.wavelength_unit != 'A': 
     123                    self.current_datainfo.source.wavelength_unit != 'A': 
    146124                        conv = Converter('A') 
    147125                        wavelength = conv(wavelength, 
    148                                           units=output.source.wavelength_unit) 
     126                                          units=self.current_datainfo.source.wavelength_unit) 
    149127                except: 
    150128                    #Not required 
     
    154132                    distance = float(line_toks[3]) 
    155133                    # Units 
    156                     if has_converter == True and detector.distance_unit != 'm': 
     134                    if has_converter == True and self.current_datainfo.detector[0].distance_unit != 'm': 
    157135                        conv = Converter('m') 
    158                         distance = conv(distance, units=detector.distance_unit) 
     136                        distance = conv(distance, 
     137                            units=self.current_datainfo.detector[0].distance_unit) 
    159138                except: 
    160139                    #Not required 
    161140                    pass 
    162                  
     141 
    163142                # Distance in meters 
    164143                try: 
     
    167146                    #Not required 
    168147                    pass 
    169                                              
     148 
    170149            if line.count("LAMBDA") > 0: 
    171                 isInfo = True 
    172                  
     150                is_info = True 
     151 
    173152            # Find center info line 
    174             if isCenter: 
    175                 isCenter = False 
     153            if is_center: 
     154                is_center = False 
    176155                line_toks = line.split() 
    177156                # Center in bin number 
     
    180159 
    181160            if line.count("BCENT") > 0: 
    182                 isCenter = True 
     161                is_center = True 
    183162            # Check version 
    184163            if line.count("Data columns") > 0: 
     
    187166            # Find data start 
    188167            if line.count("ASCII data") > 0: 
    189                 dataStarted = True 
     168                data_started = True 
    190169                continue 
    191170 
    192171            ## Read and get data. 
    193             if dataStarted == True: 
     172            if data_started == True: 
    194173                line_toks = line.split() 
    195174                if len(line_toks) == 0: 
    196175                    #empty line 
    197176                    continue 
    198                 # the number of columns must be stayed same  
     177                # the number of columns must be stayed same 
    199178                col_num = len(line_toks) 
    200179                break 
     
    204183        # index for lines_array 
    205184        lines_index = np.arange(len(lines)) 
    206          
     185 
    207186        # get the data lines 
    208187        data_lines = lines_array[lines_index >= (line_num - 1)] 
     
    213192        # split all data to one big list w/" "separator 
    214193        data_list = data_list.split() 
    215   
     194 
    216195        # Check if the size is consistent with data, otherwise 
    217196        #try the tab(\t) separator 
     
    233212            data_point = data_array.reshape(row_num, col_num).transpose() 
    234213        except: 
    235             msg = "red2d_reader: Can't read this file: Not a proper file format" 
    236             raise ValueError, msg 
     214            msg = "red2d_reader can't read this file: Incorrect number of data points provided." 
     215            raise FileContentsException(msg) 
    237216        ## Get the all data: Let's HARDcoding; Todo find better way 
    238217        # Defaults 
     
    257236        #if col_num > (6 + ver): mask[data_point[(6 + ver)] < 1] = False 
    258237        q_data = np.sqrt(qx_data*qx_data+qy_data*qy_data+qz_data*qz_data) 
    259             
    260         # Extra protection(it is needed for some data files):  
     238 
     239        # Extra protection(it is needed for some data files): 
    261240        # If all mask elements are False, put all True 
    262241        if not mask.any(): 
    263242            mask[mask == False] = True 
    264    
     243 
    265244        # Store limits of the image in q space 
    266245        xmin = np.min(qx_data) 
     
    269248        ymax = np.max(qy_data) 
    270249 
    271         # units 
    272         if has_converter == True and output.Q_unit != '1/A': 
    273             xmin = data_conv_q(xmin, units=output.Q_unit) 
    274             xmax = data_conv_q(xmax, units=output.Q_unit) 
    275             ymin = data_conv_q(ymin, units=output.Q_unit) 
    276             ymax = data_conv_q(ymax, units=output.Q_unit) 
    277              
    278250        ## calculate the range of the qx and qy_data 
    279251        x_size = math.fabs(xmax - xmin) 
    280252        y_size = math.fabs(ymax - ymin) 
    281          
     253 
    282254        # calculate the number of pixels in the each axes 
    283255        npix_y = math.floor(math.sqrt(len(data))) 
    284256        npix_x = math.floor(len(data) / npix_y) 
    285          
     257 
    286258        # calculate the size of bins 
    287259        xstep = x_size / (npix_x - 1) 
    288260        ystep = y_size / (npix_y - 1) 
    289          
     261 
    290262        # store x and y axis bin centers in q space 
    291263        x_bins = np.arange(xmin, xmax + xstep, xstep) 
    292264        y_bins = np.arange(ymin, ymax + ystep, ystep) 
    293         
     265 
    294266        # get the limits of q values 
    295267        xmin = xmin - xstep / 2 
     
    297269        ymin = ymin - ystep / 2 
    298270        ymax = ymax + ystep / 2 
    299          
     271 
    300272        #Store data in outputs 
    301273        #TODO: Check the lengths 
    302         output.data = data 
     274        self.current_dataset.data = data 
    303275        if (err_data == 1).all(): 
    304             output.err_data = np.sqrt(np.abs(data)) 
    305             output.err_data[output.err_data == 0.0] = 1.0 
     276            self.current_dataset.err_data = np.sqrt(np.abs(data)) 
     277            self.current_dataset.err_data[self.current_dataset.err_data == 0.0] = 1.0 
    306278        else: 
    307             output.err_data = err_data 
    308              
    309         output.qx_data = qx_data 
    310         output.qy_data = qy_data 
    311         output.q_data = q_data 
    312         output.mask = mask 
    313          
    314         output.x_bins = x_bins 
    315         output.y_bins = y_bins 
    316                 
    317         output.xmin = xmin 
    318         output.xmax = xmax 
    319         output.ymin = ymin 
    320         output.ymax = ymax 
    321          
    322         output.source.wavelength = wavelength 
    323          
     279            self.current_dataset.err_data = err_data 
     280 
     281        self.current_dataset.qx_data = qx_data 
     282        self.current_dataset.qy_data = qy_data 
     283        self.current_dataset.q_data = q_data 
     284        self.current_dataset.mask = mask 
     285 
     286        self.current_dataset.x_bins = x_bins 
     287        self.current_dataset.y_bins = y_bins 
     288 
     289        self.current_dataset.xmin = xmin 
     290        self.current_dataset.xmax = xmax 
     291        self.current_dataset.ymin = ymin 
     292        self.current_dataset.ymax = ymax 
     293 
     294        self.current_datainfo.source.wavelength = wavelength 
     295 
    324296        # Store pixel size in mm 
    325         detector.pixel_size.x = pixel_x 
    326         detector.pixel_size.y = pixel_y 
    327          
     297        self.current_datainfo.detector[0].pixel_size.x = pixel_x 
     298        self.current_datainfo.detector[0].pixel_size.y = pixel_y 
     299 
    328300        # Store the sample to detector distance 
    329         detector.distance = distance 
    330          
     301        self.current_datainfo.detector[0].distance = distance 
     302 
    331303        # optional data: if all of dq data == 0, do not pass to output 
    332304        if len(dqx_data) == len(qx_data) and dqx_data.any() != 0: 
     
    340312                    cos_th = qx_data / diag 
    341313                    sin_th = qy_data / diag 
    342                     output.dqx_data = np.sqrt((dqx_data * cos_th) * \ 
     314                    self.current_dataset.dqx_data = np.sqrt((dqx_data * cos_th) * \ 
    343315                                                 (dqx_data * cos_th) \ 
    344316                                                 + (dqy_data * sin_th) * \ 
    345317                                                  (dqy_data * sin_th)) 
    346                     output.dqy_data = np.sqrt((dqx_data * sin_th) * \ 
     318                    self.current_dataset.dqy_data = np.sqrt((dqx_data * sin_th) * \ 
    347319                                                 (dqx_data * sin_th) \ 
    348320                                                 + (dqy_data * cos_th) * \ 
    349321                                                  (dqy_data * cos_th)) 
    350322                else: 
    351                     output.dqx_data = dqx_data 
    352                     output.dqy_data = dqy_data 
     323                    self.current_dataset.dqx_data = dqx_data 
     324                    self.current_dataset.dqy_data = dqy_data 
    353325 
    354326        # Units of axes 
    355         if data_conv_q is not None: 
    356             output.xaxis("\\rm{Q_{x}}", output.Q_unit) 
    357             output.yaxis("\\rm{Q_{y}}", output.Q_unit) 
    358         else: 
    359             output.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
    360             output.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
    361         if data_conv_i is not None: 
    362             output.zaxis("\\rm{Intensity}", output.I_unit) 
    363         else: 
    364             output.zaxis("\\rm{Intensity}", "cm^{-1}") 
    365      
     327        self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
     328        self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
     329        self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 
     330 
    366331        # Store loading process information 
    367         output.meta_data['loader'] = self.type_name 
    368  
    369         return output 
     332        self.current_datainfo.meta_data['loader'] = self.type_name 
     333 
     334        self.send_to_output() 
  • src/sas/sascalc/dataloader/readers/sesans_reader.py

    r149b8f6 rbe43448  
    88import numpy as np 
    99import os 
    10 from sas.sascalc.dataloader.data_info import Data1D 
     10from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     11from sas.sascalc.dataloader.data_info import plottable_1D, DataInfo 
     12from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
    1113 
    1214# Check whether we have a converter available 
     
    1820_ZERO = 1e-16 
    1921 
    20  
    21 class Reader: 
     22class Reader(FileReader): 
    2223    """ 
    2324    Class to load sesans files (6 columns). 
     
    2627    type_name = "SESANS" 
    2728 
    28     # Wildcards 
     29    ## Wildcards 
    2930    type = ["SESANS files (*.ses)|*.ses", 
    3031            "SESANS files (*..sesans)|*.sesans"] 
     
    3536    allow_all = True 
    3637 
    37     def read(self, path): 
    38         """ 
    39         Load data file 
     38    def get_file_contents(self): 
     39        self.current_datainfo = DataInfo() 
     40        self.current_dataset = plottable_1D(np.array([]), np.array([])) 
     41        self.current_datainfo.isSesans = True 
     42        self.output = [] 
    4043 
    41         :param path: file path 
     44        line = self.f_open.readline() 
     45        params = {} 
     46        while not line.startswith("BEGIN_DATA"): 
     47            terms = line.split() 
     48            if len(terms) >= 2: 
     49                params[terms[0]] = " ".join(terms[1:]) 
     50            line = self.f_open.readline() 
     51        self.params = params 
    4252 
    43         :return: SESANSData1D object, or None 
     53        if "FileFormatVersion" not in self.params: 
     54            raise FileContentsException("SES file missing FileFormatVersion") 
     55        if float(self.params["FileFormatVersion"]) >= 2.0: 
     56            raise FileContentsException("SASView only supports SES version 1") 
    4457 
    45         :raise RuntimeError: when the file can't be opened 
    46         :raise ValueError: when the length of the data vectors are inconsistent 
    47         """ 
    48         if os.path.isfile(path): 
    49             basename = os.path.basename(path) 
    50             _, extension = os.path.splitext(basename) 
    51             if not (self.allow_all or extension.lower() in self.ext): 
    52                 raise RuntimeError( 
    53                     "{} has an unrecognized file extension".format(path)) 
     58        if "SpinEchoLength_unit" not in self.params: 
     59            raise FileContentsException("SpinEchoLength has no units") 
     60        if "Wavelength_unit" not in self.params: 
     61            raise FileContentsException("Wavelength has no units") 
     62        if params["SpinEchoLength_unit"] != params["Wavelength_unit"]: 
     63            raise FileContentsException("The spin echo data has rudely used " 
     64                               "different units for the spin echo length " 
     65                               "and the wavelength.  While sasview could " 
     66                               "handle this instance, it is a violation " 
     67                               "of the file format and will not be " 
     68                               "handled by other software.") 
     69 
     70        headers = self.f_open.readline().split() 
     71 
     72        self._insist_header(headers, "SpinEchoLength") 
     73        self._insist_header(headers, "Depolarisation") 
     74        self._insist_header(headers, "Depolarisation_error") 
     75        self._insist_header(headers, "Wavelength") 
     76 
     77        data = np.loadtxt(self.f_open) 
     78 
     79        if data.shape[1] != len(headers): 
     80            raise FileContentsException( 
     81                "File has {} headers, but {} columns".format( 
     82                    len(headers), 
     83                    data.shape[1])) 
     84 
     85        if not data.size: 
     86            raise FileContentsException("{} is empty".format(path)) 
     87        x = data[:, headers.index("SpinEchoLength")] 
     88        if "SpinEchoLength_error" in headers: 
     89            dx = data[:, headers.index("SpinEchoLength_error")] 
    5490        else: 
    55             raise RuntimeError("{} is not a file".format(path)) 
    56         with open(path, 'r') as input_f: 
    57             line = input_f.readline() 
    58             params = {} 
    59             while not line.startswith("BEGIN_DATA"): 
    60                 terms = line.split() 
    61                 if len(terms) >= 2: 
    62                     params[terms[0]] = " ".join(terms[1:]) 
    63                 line = input_f.readline() 
    64             self.params = params 
     91            dx = x * 0.05 
     92        lam = data[:, headers.index("Wavelength")] 
     93        if "Wavelength_error" in headers: 
     94            dlam = data[:, headers.index("Wavelength_error")] 
     95        else: 
     96            dlam = lam * 0.05 
     97        y = data[:, headers.index("Depolarisation")] 
     98        dy = data[:, headers.index("Depolarisation_error")] 
    6599 
    66             if "FileFormatVersion" not in self.params: 
    67                 raise RuntimeError("SES file missing FileFormatVersion") 
    68             if float(self.params["FileFormatVersion"]) >= 2.0: 
    69                 raise RuntimeError("SASView only supports SES version 1") 
     100        lam_unit = self._unit_fetch("Wavelength") 
     101        x, x_unit = self._unit_conversion(x, "A", 
     102                                          self._unit_fetch( 
     103                                              "SpinEchoLength")) 
     104        dx, dx_unit = self._unit_conversion( 
     105            dx, lam_unit, 
     106            self._unit_fetch("SpinEchoLength")) 
     107        dlam, dlam_unit = self._unit_conversion( 
     108            dlam, lam_unit, 
     109            self._unit_fetch("Wavelength")) 
     110        y_unit = self._unit_fetch("Depolarisation") 
    70111 
    71             if "SpinEchoLength_unit" not in self.params: 
    72                 raise RuntimeError("SpinEchoLength has no units") 
    73             if "Wavelength_unit" not in self.params: 
    74                 raise RuntimeError("Wavelength has no units") 
    75             if params["SpinEchoLength_unit"] != params["Wavelength_unit"]: 
    76                 raise RuntimeError("The spin echo data has rudely used " 
    77                                    "different units for the spin echo length " 
    78                                    "and the wavelength.  While sasview could " 
    79                                    "handle this instance, it is a violation " 
    80                                    "of the file format and will not be " 
    81                                    "handled by other software.") 
     112        self.current_dataset.x = x 
     113        self.current_dataset.y = y 
     114        self.current_dataset.lam = lam 
     115        self.current_dataset.dy = dy 
     116        self.current_dataset.dx = dx 
     117        self.current_dataset.dlam = dlam 
     118        self.current_datainfo.isSesans = True 
    82119 
    83             headers = input_f.readline().split() 
     120        self.current_datainfo._yunit = y_unit 
     121        self.current_datainfo._xunit = x_unit 
     122        self.current_datainfo.source.wavelength_unit = lam_unit 
     123        self.current_datainfo.source.wavelength = lam 
     124        self.current_datainfo.filename = os.path.basename(self.f_open.name) 
     125        self.current_dataset.xaxis(r"\rm{z}", x_unit) 
     126        # Adjust label to ln P/(lam^2 t), remove lam column refs 
     127        self.current_dataset.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit) 
     128        # Store loading process information 
     129        self.current_datainfo.meta_data['loader'] = self.type_name 
     130        self.current_datainfo.sample.name = params["Sample"] 
     131        self.current_datainfo.sample.ID = params["DataFileTitle"] 
     132        self.current_datainfo.sample.thickness = self._unit_conversion( 
     133            float(params["Thickness"]), "cm", 
     134            self._unit_fetch("Thickness"))[0] 
    84135 
    85             self._insist_header(headers, "SpinEchoLength") 
    86             self._insist_header(headers, "Depolarisation") 
    87             self._insist_header(headers, "Depolarisation_error") 
    88             self._insist_header(headers, "Wavelength") 
     136        self.current_datainfo.sample.zacceptance = ( 
     137            float(params["Theta_zmax"]), 
     138            self._unit_fetch("Theta_zmax")) 
    89139 
    90             data = np.loadtxt(input_f) 
     140        self.current_datainfo.sample.yacceptance = ( 
     141            float(params["Theta_ymax"]), 
     142            self._unit_fetch("Theta_ymax")) 
    91143 
    92             if data.shape[1] != len(headers): 
    93                 raise RuntimeError( 
    94                     "File has {} headers, but {} columns".format( 
    95                         len(headers), 
    96                         data.shape[1])) 
    97  
    98             if not data.size: 
    99                 raise RuntimeError("{} is empty".format(path)) 
    100             x = data[:, headers.index("SpinEchoLength")] 
    101             if "SpinEchoLength_error" in headers: 
    102                 dx = data[:, headers.index("SpinEchoLength_error")] 
    103             else: 
    104                 dx = x * 0.05 
    105             lam = data[:, headers.index("Wavelength")] 
    106             if "Wavelength_error" in headers: 
    107                 dlam = data[:, headers.index("Wavelength_error")] 
    108             else: 
    109                 dlam = lam * 0.05 
    110             y = data[:, headers.index("Depolarisation")] 
    111             dy = data[:, headers.index("Depolarisation_error")] 
    112  
    113             lam_unit = self._unit_fetch("Wavelength") 
    114             x, x_unit = self._unit_conversion(x, "A", 
    115                                               self._unit_fetch( 
    116                                                   "SpinEchoLength")) 
    117             dx, dx_unit = self._unit_conversion( 
    118                 dx, lam_unit, 
    119                 self._unit_fetch("SpinEchoLength")) 
    120             dlam, dlam_unit = self._unit_conversion( 
    121                 dlam, lam_unit, 
    122                 self._unit_fetch("Wavelength")) 
    123             y_unit = self._unit_fetch("Depolarisation") 
    124  
    125             output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, 
    126                             isSesans=True) 
    127  
    128             output.y_unit = y_unit 
    129             output.x_unit = x_unit 
    130             output.source.wavelength_unit = lam_unit 
    131             output.source.wavelength = lam 
    132             self.filename = output.filename = basename 
    133             output.xaxis(r"\rm{z}", x_unit) 
    134             # Adjust label to ln P/(lam^2 t), remove lam column refs 
    135             output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit) 
    136             # Store loading process information 
    137             output.meta_data['loader'] = self.type_name 
    138             output.sample.name = params["Sample"] 
    139             output.sample.ID = params["DataFileTitle"] 
    140             output.sample.thickness = self._unit_conversion( 
    141                 float(params["Thickness"]), "cm", 
    142                 self._unit_fetch("Thickness"))[0] 
    143  
    144             output.sample.zacceptance = ( 
    145                 float(params["Theta_zmax"]), 
    146                 self._unit_fetch("Theta_zmax")) 
    147  
    148             output.sample.yacceptance = ( 
    149                 float(params["Theta_ymax"]), 
    150                 self._unit_fetch("Theta_ymax")) 
    151             return output 
     144        self.send_to_output() 
    152145 
    153146    @staticmethod 
    154147    def _insist_header(headers, name): 
    155148        if name not in headers: 
    156             raise RuntimeError( 
     149            raise FileContentsException( 
    157150                "Missing {} column in spin echo data".format(name)) 
    158151 
  • src/sas/sascalc/dataloader/readers/xml_reader.py

    r235f514 rfafe52a  
    1818from lxml import etree 
    1919from lxml.builder import E 
     20from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    2021 
    2122logger = logging.getLogger(__name__) 
     
    2324PARSER = etree.ETCompatXMLParser(remove_comments=True, remove_pis=False) 
    2425 
    25 class XMLreader(): 
     26class XMLreader(FileReader): 
    2627    """ 
    2728    Generic XML read and write class. Mostly helper functions. 
     
    7475        except etree.XMLSyntaxError as xml_error: 
    7576            logger.info(xml_error) 
     77            raise xml_error 
    7678        except Exception: 
    7779            self.xml = None 
     
    9193        except etree.XMLSyntaxError as xml_error: 
    9294            logger.info(xml_error) 
    93         except Exception: 
     95            raise xml_error 
     96        except Exception as exc: 
    9497            self.xml = None 
    9598            self.xmldoc = None 
    9699            self.xmlroot = None 
     100            raise exc 
    97101 
    98102    def set_schema(self, schema): 
     
    206210        Create a unique key value for any dictionary to prevent overwriting 
    207211        Recurses until a unique key value is found. 
    208          
     212 
    209213        :param dictionary: A dictionary with any number of entries 
    210214        :param name: The index of the item to be added to dictionary 
     
    222226        Create an element tree for processing from an etree element 
    223227 
    224         :param root: etree Element(s)  
     228        :param root: etree Element(s) 
    225229        """ 
    226230        return etree.ElementTree(root) 
  • src/sas/sascalc/pr/c_extensions/Cinvertor.c

    r959eb01 rcb62bd5  
    294294} 
    295295 
    296 const char set_has_bck_doc[] = 
     296const char set_est_bck_doc[] = 
    297297        "Sets background flag\n"; 
    298298 
     
    300300 * Sets the maximum distance 
    301301 */ 
    302 static PyObject * set_has_bck(Cinvertor *self, PyObject *args) { 
    303         int has_bck; 
    304  
    305         if (!PyArg_ParseTuple(args, "i", &has_bck)) return NULL; 
    306         self->params.has_bck = has_bck; 
    307         return Py_BuildValue("i", self->params.has_bck); 
    308 } 
    309  
    310 const char get_has_bck_doc[] = 
     302static PyObject * set_est_bck(Cinvertor *self, PyObject *args) { 
     303        int est_bck; 
     304 
     305        if (!PyArg_ParseTuple(args, "i", &est_bck)) return NULL; 
     306        self->params.est_bck = est_bck; 
     307        return Py_BuildValue("i", self->params.est_bck); 
     308} 
     309 
     310const char get_est_bck_doc[] = 
    311311        "Gets background flag\n"; 
    312312 
     
    314314 * Gets the maximum distance 
    315315 */ 
    316 static PyObject * get_has_bck(Cinvertor *self, PyObject *args) { 
    317         return Py_BuildValue("i", self->params.has_bck); 
     316static PyObject * get_est_bck(Cinvertor *self, PyObject *args) { 
     317        return Py_BuildValue("i", self->params.est_bck); 
    318318} 
    319319 
     
    882882        sqrt_alpha = sqrt(self->params.alpha); 
    883883        pi = acos(-1.0); 
    884         offset = (self->params.has_bck==1) ? 0 : 1; 
     884        offset = (self->params.est_bck==1) ? 0 : 1; 
    885885 
    886886    for (j=0; j<nfunc; j++) { 
     
    892892            } 
    893893            if (accept_q(self, self->params.x[i])){ 
    894                 if (self->params.has_bck==1 && j==0) { 
     894                if (self->params.est_bck==1 && j==0) { 
    895895                    a[i*nfunc+j] = 1.0/self->params.err[i]; 
    896896                } else { 
     
    906906        } 
    907907        for (i_r=0; i_r<nr; i_r++){ 
    908             if (self->params.has_bck==1 && j==0) { 
     908            if (self->params.est_bck==1 && j==0) { 
    909909                a[(i_r+self->params.npoints)*nfunc+j] = 0.0; 
    910910            } else { 
     
    10291029                   {"set_slit_height", (PyCFunction)set_slit_height, METH_VARARGS, set_slit_height_doc}, 
    10301030                   {"get_slit_height", (PyCFunction)get_slit_height, METH_VARARGS, get_slit_height_doc}, 
    1031                    {"set_has_bck", (PyCFunction)set_has_bck, METH_VARARGS, set_has_bck_doc}, 
    1032                    {"get_has_bck", (PyCFunction)get_has_bck, METH_VARARGS, get_has_bck_doc}, 
     1031                   {"set_est_bck", (PyCFunction)set_est_bck, METH_VARARGS, set_est_bck_doc}, 
     1032                   {"get_est_bck", (PyCFunction)get_est_bck, METH_VARARGS, get_est_bck_doc}, 
    10331033                   {"get_nx", (PyCFunction)get_nx, METH_VARARGS, get_nx_doc}, 
    10341034                   {"get_ny", (PyCFunction)get_ny, METH_VARARGS, get_ny_doc}, 
  • src/sas/sascalc/pr/c_extensions/invertor.c

    r959eb01 rcb62bd5  
    2020        pars->q_min = -1.0; 
    2121        pars->q_max = -1.0; 
    22         pars->has_bck = 0; 
     22        pars->est_bck = 0; 
    2323} 
    2424 
     
    313313    return sqrt(sum_r2/(2.0*sum)); 
    314314} 
    315  
  • src/sas/sascalc/pr/c_extensions/invertor.h

    r959eb01 rcb62bd5  
    2727    double q_max; 
    2828    /// Flag for whether or not to evalute a constant background while inverting 
    29     int has_bck; 
     29    int est_bck; 
    3030    /// Slit height in units of q [A-1] 
    3131    double slit_height; 
  • src/sas/sascalc/pr/invertor.py

    r45dffa69 rcb62bd5  
    121121         self.q_min, self.q_max, 
    122122         self.x, self.y, 
    123          self.err, self.has_bck, 
     123         self.err, self.est_bck, 
    124124         self.slit_height, self.slit_width) = state 
    125125 
     
    133133                 self.q_min, self.q_max, 
    134134                 self.x, self.y, 
    135                  self.err, self.has_bck, 
     135                 self.err, self.est_bck, 
    136136                 self.slit_height, self.slit_width, 
    137137                ) 
     
    175175        elif name == 'slit_width': 
    176176            return self.set_slit_width(value) 
    177         elif name == 'has_bck': 
     177        elif name == 'est_bck': 
    178178            if value == True: 
    179                 return self.set_has_bck(1) 
     179                return self.set_est_bck(1) 
    180180            elif value == False: 
    181                 return self.set_has_bck(0) 
     181                return self.set_est_bck(0) 
    182182            else: 
    183                 raise ValueError, "Invertor: has_bck can only be True or False" 
     183                raise ValueError, "Invertor: est_bck can only be True or False" 
    184184 
    185185        return Cinvertor.__setattr__(self, name, value) 
     
    220220        elif name == 'slit_width': 
    221221            return self.get_slit_width() 
    222         elif name == 'has_bck': 
    223             value = self.get_has_bck() 
     222        elif name == 'est_bck': 
     223            value = self.get_est_bck() 
    224224            if value == 1: 
    225225                return True 
     
    248248        invertor.y = self.y 
    249249        invertor.err = self.err 
    250         invertor.has_bck = self.has_bck 
     250        invertor.est_bck = self.est_bck 
     251        invertor.background = self.background 
    251252        invertor.slit_height = self.slit_height 
    252253        invertor.slit_width = self.slit_width 
     
    290291        """ 
    291292        # Reset the background value before proceeding 
    292         self.background = 0.0 
    293         return self.lstsq(nfunc, nr=nr) 
     293        # self.background = 0.0 
     294        if not self.est_bck: 
     295            self.y -= self.background 
     296        out, cov = self.lstsq(nfunc, nr=nr) 
     297        if not self.est_bck: 
     298            self.y += self.background 
     299        return out, cov 
    294300 
    295301    def iq(self, out, q): 
     
    454460 
    455461        # If we need to fit the background, add a term 
    456         if self.has_bck == True: 
     462        if self.est_bck == True: 
    457463            nfunc_0 = nfunc 
    458464            nfunc += 1 
     
    500506 
    501507        # Keep a copy of the last output 
    502         if self.has_bck == False: 
    503             self.background = 0 
     508        if self.est_bck == False: 
    504509            self.out = c 
    505510            self.cov = err 
     
    653658        file.write("#slit_width=%g\n" % self.slit_width) 
    654659        file.write("#background=%g\n" % self.background) 
    655         if self.has_bck == True: 
     660        if self.est_bck == True: 
    656661            file.write("#has_bck=1\n") 
    657662        else: 
     
    734739                        toks = line.split('=') 
    735740                        if int(toks[1]) == 1: 
    736                             self.has_bck = True 
     741                            self.est_bck = True 
    737742                        else: 
    738                             self.has_bck = False 
     743                            self.est_bck = False 
    739744 
    740745                    # Now read in the parameters 
  • src/sas/sasgui/guiframe/local_perspectives/data_loader/data_loader.py

    r235f514 rdcb91cf  
    1111 
    1212from sas.sascalc.dataloader.loader import Loader 
     13from sas.sascalc.dataloader.loader_exceptions import NoKnownLoaderException 
    1314from sas.sasgui.guiframe.plugin_base import PluginBase 
    1415from sas.sasgui.guiframe.events import StatusEvent 
     
    4142APPLICATION_WLIST = config.APPLICATION_WLIST 
    4243 
     44 
    4345class Plugin(PluginBase): 
    4446 
     
    5658        """ 
    5759        # menu for data files 
    58         menu_list = [] 
    5960        data_file_hint = "load one or more data in the application" 
    6061        menu_list = [('&Load Data File(s)', data_file_hint, self.load_data)] 
    6162        gui_style = self.parent.get_style() 
    6263        style = gui_style & GUIFRAME.MULTIPLE_APPLICATIONS 
    63         style1 = gui_style & GUIFRAME.DATALOADER_ON 
    6464        if style == GUIFRAME.MULTIPLE_APPLICATIONS: 
    6565            # menu for data from folder 
     
    102102        self.get_data(file_list) 
    103103 
    104  
    105104    def can_load_data(self): 
    106105        """ 
     
    108107        """ 
    109108        return True 
    110  
    111109 
    112110    def _load_folder(self, event): 
     
    140138        """ 
    141139        if error is not None or str(error).strip() != "": 
    142             dial = wx.MessageDialog(self.parent, str(error), 'Error Loading File', 
     140            dial = wx.MessageDialog(self.parent, str(error), 
     141                                    'Error Loading File', 
    143142                                    wx.OK | wx.ICON_EXCLAMATION) 
    144143            dial.ShowModal() 
     
    149148        """ 
    150149        if os.path.isdir(path): 
    151             return [os.path.join(os.path.abspath(path), filename) for filename in os.listdir(path)] 
     150            return [os.path.join(os.path.abspath(path), filename) for filename 
     151                    in os.listdir(path)] 
    152152 
    153153    def _process_data_and_errors(self, item, p_file, output, message): 
     
    178178        for p_file in path: 
    179179            basename = os.path.basename(p_file) 
     180            # Skip files that start with a period 
     181            if basename.startswith("."): 
     182                msg = "The folder included a potential hidden file - %s." \ 
     183                      % basename 
     184                msg += " Do you wish to load this file as data?" 
     185                msg_box = wx.MessageDialog(None, msg, 'Warning', 
     186                                           wx.OK | wx.CANCEL) 
     187                if msg_box.ShowModal() == wx.ID_CANCEL: 
     188                    continue 
    180189            _, extension = os.path.splitext(basename) 
    181190            if extension.lower() in EXTENSIONS: 
     
    213222                info="info") 
    214223 
    215             except: 
    216                 logger.error(sys.exc_value) 
    217  
    218                 error_message = "The Data file you selected could not be loaded.\n" 
    219                 error_message += "Make sure the content of your file" 
    220                 error_message += " is properly formatted.\n" 
    221                 error_message += "When contacting the SasView team, mention the" 
    222                 error_message += " following:\n" 
    223                 error_message += "Error: " + str(sys.exc_info()[1]) 
    224                 file_errors[basename] = [error_message] 
    225                 self.load_update(output=output, message=error_message, info="warning") 
     224            except NoKnownLoaderException as e: 
     225                exception_occurred = True 
     226                logger.error(e.message) 
     227 
     228                error_message = "Loading data failed!\n" + e.message 
     229                self.load_update(output=None, message=e.message, info="warning") 
     230 
     231            except Exception as e: 
     232                exception_occurred = True 
     233                logger.error(e.message) 
     234 
     235                file_err = "The Data file you selected could not be " 
     236                file_err += "loaded.\nMake sure the content of your file" 
     237                file_err += " is properly formatted.\n" 
     238                file_err += "When contacting the SasView team, mention the" 
     239                file_err += " following:\n" 
     240                file_err += e.message 
     241                file_errors[basename] = [file_err] 
    226242 
    227243        if len(file_errors) > 0: 
     
    233249                    error_message += message + "\n" 
    234250                error_message += "\n" 
    235             self.load_update(output=output, message=error_message, info="error") 
    236  
    237         self.load_complete(output=output, message="Loading data complete!", 
    238             info="info") 
     251            if not exception_occurred: # Some data loaded but with errors 
     252                self.load_update(output=output, message=error_message, info="error") 
     253 
     254        if not exception_occurred: # Everything loaded as expected 
     255            self.load_complete(output=output, message="Loading data complete!", 
     256                               info="info") 
     257        else: 
     258            self.load_complete(output=None, message=error_message, info="error") 
     259 
    239260 
    240261    def load_update(self, output=None, message="", info="warning"): 
     
    245266            wx.PostEvent(self.parent, StatusEvent(status=message, info=info, 
    246267                                                  type="progress")) 
    247     def load_complete(self, output, message="", error_message="", path=None, 
    248                       info="warning"): 
    249         """ 
    250          post message to  status bar and return list of data 
    251         """ 
    252         wx.PostEvent(self.parent, StatusEvent(status=message, 
    253                                               info=info, 
     268 
     269    def load_complete(self, output, message="", info="warning"): 
     270        """ 
     271         post message to status bar and return list of data 
     272        """ 
     273        wx.PostEvent(self.parent, StatusEvent(status=message, info=info, 
    254274                                              type="stop")) 
    255         # if error_message != "": 
    256         #    self.load_error(error_message) 
    257         self.parent.add_data(data_list=output) 
     275        if output is not None: 
     276            self.parent.add_data(data_list=output) 
  • src/sas/sasgui/guiframe/local_perspectives/plotting/plotting.py

    r235f514 r2d9526d  
    1414import wx 
    1515import sys 
     16from copy import deepcopy 
    1617from sas.sasgui.guiframe.events import EVT_NEW_PLOT 
    1718from sas.sasgui.guiframe.events import EVT_PLOT_QRANGE 
     
    275276                action_check = True 
    276277            else: 
     278                if action_string == 'update': 
     279                    # Update all existing plots of data with this ID 
     280                    for data in event.plots: 
     281                        for panel in self.plot_panels.values(): 
     282                            if data.id in panel.plots.keys(): 
     283                                plot_exists = True 
     284                                # Pass each panel it's own copy of the data 
     285                                # that's being updated, otherwise things like 
     286                                # colour and line thickness are unintentionally 
     287                                # synced across panels 
     288                                self.update_panel(deepcopy(data), panel) 
     289                    return 
     290                     
    277291                group_id = event.group_id 
    278                 if group_id in self.plot_panels.keys(): 
     292                if group_id in self.plot_panels: 
    279293                    #remove data from panel 
    280294                    if action_string == 'remove': 
  • src/sas/sasgui/perspectives/calculator/model_editor.py

    ra1b8fee r23359ccb  
    106106        self.model2_string = "cylinder" 
    107107        self.name = 'Sum' + M_NAME 
    108         self.factor = 'scale_factor' 
    109108        self._notes = '' 
    110109        self._operator = '+' 
     
    133132        self.model2_name = str(self.model2.GetValue()) 
    134133        self.good_name = True 
    135         self.fill_oprator_combox() 
     134        self.fill_operator_combox() 
    136135 
    137136    def _layout_name(self): 
     
    491490        a sum or multiply model then create the appropriate string 
    492491        """ 
    493  
    494492        name = '' 
    495  
    496493        if operator == '*': 
    497494            name = 'Multi' 
    498             factor = 'BackGround' 
    499             f_oper = '+' 
     495            factor = 'background' 
    500496        else: 
    501497            name = 'Sum' 
    502498            factor = 'scale_factor' 
    503             f_oper = '*' 
    504  
    505         self.factor = factor 
     499 
    506500        self._operator = operator 
    507         self.explanation = "  Plugin Model = %s %s (model1 %s model2)\n" % \ 
    508                            (self.factor, f_oper, self._operator) 
     501        self.explanation = ("  Plugin_model = scale_factor * (model_1 {} " 
     502            "model_2) + background").format(operator) 
    509503        self.explanationctr.SetLabel(self.explanation) 
    510504        self.name = name + M_NAME 
    511505 
    512506 
    513     def fill_oprator_combox(self): 
     507    def fill_operator_combox(self): 
    514508        """ 
    515509        fill the current combobox with the operator 
     
    527521        return [self.model1_name, self.model2_name] 
    528522 
    529     def write_string(self, fname, name1, name2): 
     523    def write_string(self, fname, model1_name, model2_name): 
    530524        """ 
    531525        Write and Save file 
     
    533527        self.fname = fname 
    534528        description = self.desc_tcl.GetValue().lstrip().rstrip() 
    535         if description == '': 
    536             description = name1 + self._operator + name2 
    537         text = self._operator_choice.GetValue() 
    538         if text.count('+') > 0: 
    539             factor = 'scale_factor' 
    540             f_oper = '*' 
    541             default_val = '1.0' 
    542         else: 
    543             factor = 'BackGround' 
    544             f_oper = '+' 
    545             default_val = '0.0' 
    546         path = self.fname 
    547         try: 
    548             out_f = open(path, 'w') 
    549         except: 
    550             raise 
    551         lines = SUM_TEMPLATE.split('\n') 
    552         for line in lines: 
    553             try: 
    554                 if line.count("scale_factor"): 
    555                     line = line.replace('scale_factor', factor) 
    556                     #print "scale_factor", line 
    557                 if line.count("= %s"): 
    558                     out_f.write(line % (default_val) + "\n") 
    559                 elif line.count("import Model as P1"): 
    560                     if self.is_p1_custom: 
    561                         line = line.replace('#', '') 
    562                         out_f.write(line % name1 + "\n") 
    563                     else: 
    564                         out_f.write(line + "\n") 
    565                 elif line.count("import %s as P1"): 
    566                     if not self.is_p1_custom: 
    567                         line = line.replace('#', '') 
    568                         out_f.write(line % (name1) + "\n") 
    569                     else: 
    570                         out_f.write(line + "\n") 
    571                 elif line.count("import Model as P2"): 
    572                     if self.is_p2_custom: 
    573                         line = line.replace('#', '') 
    574                         out_f.write(line % name2 + "\n") 
    575                     else: 
    576                         out_f.write(line + "\n") 
    577                 elif line.count("import %s as P2"): 
    578                     if not self.is_p2_custom: 
    579                         line = line.replace('#', '') 
    580                         out_f.write(line % (name2) + "\n") 
    581                     else: 
    582                         out_f.write(line + "\n") 
    583                 elif line.count("P1 = find_model"): 
    584                     out_f.write(line % (name1) + "\n") 
    585                 elif line.count("P2 = find_model"): 
    586                     out_f.write(line % (name2) + "\n") 
    587  
    588                 elif line.count("self.description = '%s'"): 
    589                     out_f.write(line % description + "\n") 
    590                 #elif line.count("run") and line.count("%s"): 
    591                 #    out_f.write(line % self._operator + "\n") 
    592                 #elif line.count("evalDistribution") and line.count("%s"): 
    593                 #    out_f.write(line % self._operator + "\n") 
    594                 elif line.count("return") and line.count("%s") == 2: 
    595                     #print "line return", line 
    596                     out_f.write(line % (f_oper, self._operator) + "\n") 
    597                 elif line.count("out2")and line.count("%s"): 
    598                     out_f.write(line % self._operator + "\n") 
    599                 else: 
    600                     out_f.write(line + "\n") 
    601             except: 
    602                 raise 
    603         out_f.close() 
    604         #else: 
    605         #    msg = "Name exists already." 
     529        desc_line = '' 
     530        if description.strip() != '': 
     531            # Sasmodels generates a description for us. If the user provides 
     532            # their own description, add a line to overwrite the sasmodels one 
     533            desc_line = "\nmodel_info.description = '{}'".format(description) 
     534        name = os.path.splitext(os.path.basename(self.fname))[0] 
     535        output = SUM_TEMPLATE.format(name=name, model1=model1_name,  
     536            model2=model2_name, operator=self._operator, desc_line=desc_line) 
     537        with open(self.fname, 'w') as out_f: 
     538            out_f.write(output) 
    606539 
    607540    def compile_file(self, path): 
     
    643576        self.name_hsizer = None 
    644577        self.name_tcl = None 
     578        self.overwrite_cb = None 
    645579        self.desc_sizer = None 
    646580        self.desc_tcl = None 
     
    657591        self.warning = "" 
    658592        #This does not seem to be used anywhere so commenting out for now 
    659         #    -- PDB 2/26/17  
     593        #    -- PDB 2/26/17 
    660594        #self._description = "New Plugin Model" 
    661595        self.function_tcl = None 
     
    689623        #title name [string] 
    690624        name_txt = wx.StaticText(self, -1, 'Function Name : ') 
    691         overwrite_cb = wx.CheckBox(self, -1, "Overwrite existing plugin model of this name?", (10, 10)) 
    692         overwrite_cb.SetValue(False) 
    693         overwrite_cb.SetToolTipString("Overwrite it if already exists?") 
    694         wx.EVT_CHECKBOX(self, overwrite_cb.GetId(), self.on_over_cb) 
     625        self.overwrite_cb = wx.CheckBox(self, -1, "Overwrite existing plugin model of this name?", (10, 10)) 
     626        self.overwrite_cb.SetValue(False) 
     627        self.overwrite_cb.SetToolTipString("Overwrite it if already exists?") 
     628        wx.EVT_CHECKBOX(self, self.overwrite_cb.GetId(), self.on_over_cb) 
    695629        self.name_tcl = wx.TextCtrl(self, -1, size=(PANEL_WIDTH * 3 / 5, -1)) 
    696630        self.name_tcl.Bind(wx.EVT_TEXT_ENTER, self.on_change_name) 
     
    700634        self.name_tcl.SetToolTipString(hint_name) 
    701635        self.name_hsizer.AddMany([(self.name_tcl, 0, wx.LEFT | wx.TOP, 0), 
    702                                   (overwrite_cb, 0, wx.LEFT, 20)]) 
     636                                  (self.overwrite_cb, 0, wx.LEFT, 20)]) 
    703637        self.name_sizer.AddMany([(name_txt, 0, wx.LEFT | wx.TOP, 10), 
    704638                                 (self.name_hsizer, 0, 
     
    740674        self.param_sizer.AddMany([(param_txt, 0, wx.LEFT, 10), 
    741675                                  (self.param_tcl, 1, wx.EXPAND | wx.ALL, 10)]) 
    742          
     676 
    743677        # Parameters with polydispersity 
    744678        pd_param_txt = wx.StaticText(self, -1, 'Fit Parameters requiring ' + \ 
     
    755689        self.pd_param_tcl.setDisplayLineNumbers(True) 
    756690        self.pd_param_tcl.SetToolTipString(pd_param_tip) 
    757          
     691 
    758692        self.param_sizer.AddMany([(pd_param_txt, 0, wx.LEFT, 10), 
    759693                                  (self.pd_param_tcl, 1, wx.EXPAND | wx.ALL, 10)]) 
     
    995929            info = 'Error' 
    996930            color = 'red' 
     931            self.overwrite_cb.SetValue(True) 
     932            self.overwrite_name = True 
    997933        else: 
    998934            self._notes = result 
     
    1030966        if has_scipy: 
    1031967            lines.insert(0, 'import scipy') 
    1032          
    1033         # Think about 2D later         
     968 
     969        # Think about 2D later 
    1034970        #self.is_2d = func_str.count("#self.ndim = 2") 
    1035971        #line_2d = '' 
    1036972        #if self.is_2d: 
    1037973        #    line_2d = CUSTOM_2D_TEMP.split('\n') 
    1038          
    1039         # Also think about test later         
     974 
     975        # Also think about test later 
    1040976        #line_test = TEST_TEMPLATE.split('\n') 
    1041977        #local_params = '' 
     
    1043979        spaces4  = ' '*4 
    1044980        spaces13 = ' '*13 
    1045         spaces16 = ' '*16      
     981        spaces16 = ' '*16 
    1046982        param_names = []    # to store parameter names 
    1047983        has_scipy = func_str.count("scipy.") 
     
    1055991            out_f.write(line + '\n') 
    1056992            if line.count('#name'): 
    1057                 out_f.write('name = "%s" \n' % name)                
     993                out_f.write('name = "%s" \n' % name) 
    1058994            elif line.count('#title'): 
    1059                 out_f.write('title = "User model for %s"\n' % name)                
     995                out_f.write('title = "User model for %s"\n' % name) 
    1060996            elif line.count('#description'): 
    1061                 out_f.write('description = "%s"\n' % desc_str)                
     997                out_f.write('description = "%s"\n' % desc_str) 
    1062998            elif line.count('#parameters'): 
    1063999                out_f.write('parameters = [ \n') 
     
    10651001                    p_line = param_line.lstrip().rstrip() 
    10661002                    if p_line: 
    1067                         pname, pvalue = self.get_param_helper(p_line) 
     1003                        pname, pvalue, desc = self.get_param_helper(p_line) 
    10681004                        param_names.append(pname) 
    1069                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', ''],\n" % (spaces16, pname, pvalue)) 
     1005                        out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], '', '%s'],\n" % (spaces16, pname, pvalue, desc)) 
    10701006                for param_line in pd_param_str.split('\n'): 
    10711007                    p_line = param_line.lstrip().rstrip() 
    10721008                    if p_line: 
    1073                         pname, pvalue = self.get_param_helper(p_line) 
     1009                        pname, pvalue, desc = self.get_param_helper(p_line) 
    10741010                        param_names.append(pname) 
    1075                         out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', ''],\n" % (spaces16, pname, pvalue)) 
     1011                        out_f.write("%s['%s', '', %s, [-numpy.inf, numpy.inf], 'volume', '%s'],\n" % (spaces16, pname, pvalue, desc)) 
    10761012                out_f.write('%s]\n' % spaces13) 
    1077              
     1013 
    10781014        # No form_volume or ER available in simple model editor 
    10791015        out_f.write('def form_volume(*arg): \n') 
     
    10821018        out_f.write('def ER(*arg): \n') 
    10831019        out_f.write('    return 1.0 \n') 
    1084          
     1020 
    10851021        # function to compute 
    10861022        out_f.write('\n') 
     
    10911027        for func_line in func_str.split('\n'): 
    10921028            out_f.write('%s%s\n' % (spaces4, func_line)) 
    1093          
     1029 
    10941030        Iqxy_string = 'return Iq(numpy.sqrt(x**2+y**2) ' 
    1095              
     1031 
    10961032        out_f.write('\n') 
    10971033        out_f.write('def Iqxy(x, y ') 
     
    11131049        items = line.split(";") 
    11141050        for item in items: 
    1115             name = item.split("=")[0].lstrip().rstrip() 
     1051            name = item.split("=")[0].strip() 
     1052            description = "" 
    11161053            try: 
    1117                 value = item.split("=")[1].lstrip().rstrip() 
     1054                value = item.split("=")[1].strip() 
     1055                if value.count("#"): 
     1056                    # If line ends in a comment, remove it before parsing float 
     1057                    index = value.index("#") 
     1058                    description = value[(index + 1):].strip() 
     1059                    value = value[:value.index("#")].strip() 
    11181060                float(value) 
    1119             except: 
     1061            except ValueError: 
    11201062                value = 1.0 # default 
    11211063 
    1122         return name, value 
     1064        return name, value, description 
    11231065 
    11241066    def set_function_helper(self, line): 
     
    12041146import numpy 
    12051147 
    1206 #name  
     1148#name 
    12071149 
    12081150#title 
     
    12101152#description 
    12111153 
    1212 #parameters  
     1154#parameters 
    12131155 
    12141156""" 
     
    12691211""" 
    12701212SUM_TEMPLATE = """ 
    1271 # A sample of an experimental model function for Sum/Multiply(Pmodel1,Pmodel2) 
    1272 import os 
    1273 import sys 
    1274 import copy 
    1275 import collections 
    1276  
    1277 import numpy 
    1278  
    1279 from sas.sascalc.fit.pluginmodel import Model1DPlugin 
    1280 from sasmodels.sasview_model import find_model 
    1281  
    1282 class Model(Model1DPlugin): 
    1283     name = os.path.splitext(os.path.basename(__file__))[0] 
    1284     is_multiplicity_model = False 
    1285     def __init__(self, multiplicity=1): 
    1286         Model1DPlugin.__init__(self, name='') 
    1287         P1 = find_model('%s') 
    1288         P2 = find_model('%s') 
    1289         p_model1 = P1() 
    1290         p_model2 = P2() 
    1291         ## Setting  model name model description 
    1292         self.description = '%s' 
    1293         if self.name.rstrip().lstrip() == '': 
    1294             self.name = self._get_name(p_model1.name, p_model2.name) 
    1295         if self.description.rstrip().lstrip() == '': 
    1296             self.description = p_model1.name 
    1297             self.description += p_model2.name 
    1298             self.fill_description(p_model1, p_model2) 
    1299  
    1300         ## Define parameters 
    1301         self.params = collections.OrderedDict() 
    1302  
    1303         ## Parameter details [units, min, max] 
    1304         self.details = {} 
    1305         ## Magnetic Panrameters 
    1306         self.magnetic_params = [] 
    1307         # non-fittable parameters 
    1308         self.non_fittable = p_model1.non_fittable 
    1309         self.non_fittable += p_model2.non_fittable 
    1310  
    1311         ##models 
    1312         self.p_model1= p_model1 
    1313         self.p_model2= p_model2 
    1314  
    1315  
    1316         ## dispersion 
    1317         self._set_dispersion() 
    1318         ## Define parameters 
    1319         self._set_params() 
    1320         ## New parameter:scaling_factor 
    1321         self.params['scale_factor'] = %s 
    1322  
    1323         ## Parameter details [units, min, max] 
    1324         self._set_details() 
    1325         self.details['scale_factor'] = ['', 0.0, numpy.inf] 
    1326  
    1327  
    1328         #list of parameter that can be fitted 
    1329         self._set_fixed_params() 
    1330  
    1331         ## parameters with orientation 
    1332         self.orientation_params = [] 
    1333         for item in self.p_model1.orientation_params: 
    1334             new_item = "p1_" + item 
    1335             if not new_item in self.orientation_params: 
    1336                 self.orientation_params.append(new_item) 
    1337  
    1338         for item in self.p_model2.orientation_params: 
    1339             new_item = "p2_" + item 
    1340             if not new_item in self.orientation_params: 
    1341                 self.orientation_params.append(new_item) 
    1342         ## magnetic params 
    1343         self.magnetic_params = [] 
    1344         for item in self.p_model1.magnetic_params: 
    1345             new_item = "p1_" + item 
    1346             if not new_item in self.magnetic_params: 
    1347                 self.magnetic_params.append(new_item) 
    1348  
    1349         for item in self.p_model2.magnetic_params: 
    1350             new_item = "p2_" + item 
    1351             if not new_item in self.magnetic_params: 
    1352                 self.magnetic_params.append(new_item) 
    1353         # get multiplicity if model provide it, else 1. 
    1354         try: 
    1355             multiplicity1 = p_model1.multiplicity 
    1356             try: 
    1357                 multiplicity2 = p_model2.multiplicity 
    1358             except: 
    1359                 multiplicity2 = 1 
    1360         except: 
    1361             multiplicity1 = 1 
    1362             multiplicity2 = 1 
    1363         ## functional multiplicity of the model 
    1364         self.multiplicity1 = multiplicity1 
    1365         self.multiplicity2 = multiplicity2 
    1366         self.multiplicity_info = [] 
    1367  
    1368     def _clone(self, obj): 
    1369         import copy 
    1370         obj.params     = copy.deepcopy(self.params) 
    1371         obj.description     = copy.deepcopy(self.description) 
    1372         obj.details    = copy.deepcopy(self.details) 
    1373         obj.dispersion = copy.deepcopy(self.dispersion) 
    1374         obj.p_model1  = self.p_model1.clone() 
    1375         obj.p_model2  = self.p_model2.clone() 
    1376         #obj = copy.deepcopy(self) 
    1377         return obj 
    1378  
    1379     def _get_name(self, name1, name2): 
    1380         p1_name = self._get_upper_name(name1) 
    1381         if not p1_name: 
    1382             p1_name = name1 
    1383         name = p1_name 
    1384         name += "_and_" 
    1385         p2_name = self._get_upper_name(name2) 
    1386         if not p2_name: 
    1387             p2_name = name2 
    1388         name += p2_name 
    1389         return name 
    1390  
    1391     def _get_upper_name(self, name=None): 
    1392         if name is None: 
    1393             return "" 
    1394         upper_name = "" 
    1395         str_name = str(name) 
    1396         for index in range(len(str_name)): 
    1397             if str_name[index].isupper(): 
    1398                 upper_name += str_name[index] 
    1399         return upper_name 
    1400  
    1401     def _set_dispersion(self): 
    1402         self.dispersion = collections.OrderedDict() 
    1403         ##set dispersion only from p_model 
    1404         for name , value in self.p_model1.dispersion.iteritems(): 
    1405             #if name.lower() not in self.p_model1.orientation_params: 
    1406             new_name = "p1_" + name 
    1407             self.dispersion[new_name]= value 
    1408         for name , value in self.p_model2.dispersion.iteritems(): 
    1409             #if name.lower() not in self.p_model2.orientation_params: 
    1410             new_name = "p2_" + name 
    1411             self.dispersion[new_name]= value 
    1412  
    1413     def function(self, x=0.0): 
    1414         return 0 
    1415  
    1416     def getProfile(self): 
    1417         try: 
    1418             x,y = self.p_model1.getProfile() 
    1419         except: 
    1420             x = None 
    1421             y = None 
    1422  
    1423         return x, y 
    1424  
    1425     def _set_params(self): 
    1426         for name , value in self.p_model1.params.iteritems(): 
    1427             # No 2D-supported 
    1428             #if name not in self.p_model1.orientation_params: 
    1429             new_name = "p1_" + name 
    1430             self.params[new_name]= value 
    1431  
    1432         for name , value in self.p_model2.params.iteritems(): 
    1433             # No 2D-supported 
    1434             #if name not in self.p_model2.orientation_params: 
    1435             new_name = "p2_" + name 
    1436             self.params[new_name]= value 
    1437  
    1438         # Set "scale" as initializing 
    1439         self._set_scale_factor() 
    1440  
    1441  
    1442     def _set_details(self): 
    1443         for name ,detail in self.p_model1.details.iteritems(): 
    1444             new_name = "p1_" + name 
    1445             #if new_name not in self.orientation_params: 
    1446             self.details[new_name]= detail 
    1447  
    1448         for name ,detail in self.p_model2.details.iteritems(): 
    1449             new_name = "p2_" + name 
    1450             #if new_name not in self.orientation_params: 
    1451             self.details[new_name]= detail 
    1452  
    1453     def _set_scale_factor(self): 
    1454         pass 
    1455  
    1456  
    1457     def setParam(self, name, value): 
    1458         # set param to this (p1, p2) model 
    1459         self._setParamHelper(name, value) 
    1460  
    1461         ## setParam to p model 
    1462         model_pre = '' 
    1463         new_name = '' 
    1464         name_split = name.split('_', 1) 
    1465         if len(name_split) == 2: 
    1466             model_pre = name.split('_', 1)[0] 
    1467             new_name = name.split('_', 1)[1] 
    1468         if model_pre == "p1": 
    1469             if new_name in self.p_model1.getParamList(): 
    1470                 self.p_model1.setParam(new_name, value) 
    1471         elif model_pre == "p2": 
    1472              if new_name in self.p_model2.getParamList(): 
    1473                 self.p_model2.setParam(new_name, value) 
    1474         elif name == 'scale_factor': 
    1475             self.params['scale_factor'] = value 
    1476         else: 
    1477             raise ValueError, "Model does not contain parameter %s" % name 
    1478  
    1479     def getParam(self, name): 
    1480         # Look for dispersion parameters 
    1481         toks = name.split('.') 
    1482         if len(toks)==2: 
    1483             for item in self.dispersion.keys(): 
    1484                 # 2D not supported 
    1485                 if item.lower()==toks[0].lower(): 
    1486                     for par in self.dispersion[item]: 
    1487                         if par.lower() == toks[1].lower(): 
    1488                             return self.dispersion[item][par] 
    1489         else: 
    1490             # Look for standard parameter 
    1491             for item in self.params.keys(): 
    1492                 if item.lower()==name.lower(): 
    1493                     return self.params[item] 
    1494         return 
    1495         #raise ValueError, "Model does not contain parameter %s" % name 
    1496  
    1497     def _setParamHelper(self, name, value): 
    1498         # Look for dispersion parameters 
    1499         toks = name.split('.') 
    1500         if len(toks)== 2: 
    1501             for item in self.dispersion.keys(): 
    1502                 if item.lower()== toks[0].lower(): 
    1503                     for par in self.dispersion[item]: 
    1504                         if par.lower() == toks[1].lower(): 
    1505                             self.dispersion[item][par] = value 
    1506                             return 
    1507         else: 
    1508             # Look for standard parameter 
    1509             for item in self.params.keys(): 
    1510                 if item.lower()== name.lower(): 
    1511                     self.params[item] = value 
    1512                     return 
    1513  
    1514         raise ValueError, "Model does not contain parameter %s" % name 
    1515  
    1516  
    1517     def _set_fixed_params(self): 
    1518         self.fixed = [] 
    1519         for item in self.p_model1.fixed: 
    1520             new_item = "p1" + item 
    1521             self.fixed.append(new_item) 
    1522         for item in self.p_model2.fixed: 
    1523             new_item = "p2" + item 
    1524             self.fixed.append(new_item) 
    1525  
    1526         self.fixed.sort() 
    1527  
    1528  
    1529     def run(self, x = 0.0): 
    1530         self._set_scale_factor() 
    1531         return self.params['scale_factor'] %s \ 
    1532 (self.p_model1.run(x) %s self.p_model2.run(x)) 
    1533  
    1534     def runXY(self, x = 0.0): 
    1535         self._set_scale_factor() 
    1536         return self.params['scale_factor'] %s \ 
    1537 (self.p_model1.runXY(x) %s self.p_model2.runXY(x)) 
    1538  
    1539     ## Now (May27,10) directly uses the model eval function 
    1540     ## instead of the for-loop in Base Component. 
    1541     def evalDistribution(self, x = []): 
    1542         self._set_scale_factor() 
    1543         return self.params['scale_factor'] %s \ 
    1544 (self.p_model1.evalDistribution(x) %s \ 
    1545 self.p_model2.evalDistribution(x)) 
    1546  
    1547     def set_dispersion(self, parameter, dispersion): 
    1548         value= None 
    1549         new_pre = parameter.split("_", 1)[0] 
    1550         new_parameter = parameter.split("_", 1)[1] 
    1551         try: 
    1552             if new_pre == 'p1' and \ 
    1553 new_parameter in self.p_model1.dispersion.keys(): 
    1554                 value= self.p_model1.set_dispersion(new_parameter, dispersion) 
    1555             if new_pre == 'p2' and \ 
    1556 new_parameter in self.p_model2.dispersion.keys(): 
    1557                 value= self.p_model2.set_dispersion(new_parameter, dispersion) 
    1558             self._set_dispersion() 
    1559             return value 
    1560         except: 
    1561             raise 
    1562  
    1563     def fill_description(self, p_model1, p_model2): 
    1564         description = "" 
    1565         description += "This model gives the summation or multiplication of" 
    1566         description += "%s and %s. "% ( p_model1.name, p_model2.name ) 
    1567         self.description += description 
    1568  
    1569 if __name__ == "__main__": 
    1570     m1= Model() 
    1571     #m1.setParam("p1_scale", 25) 
    1572     #m1.setParam("p1_length", 1000) 
    1573     #m1.setParam("p2_scale", 100) 
    1574     #m1.setParam("p2_rg", 100) 
    1575     out1 = m1.runXY(0.01) 
    1576  
    1577     m2= Model() 
    1578     #m2.p_model1.setParam("scale", 25) 
    1579     #m2.p_model1.setParam("length", 1000) 
    1580     #m2.p_model2.setParam("scale", 100) 
    1581     #m2.p_model2.setParam("rg", 100) 
    1582     out2 = m2.p_model1.runXY(0.01) %s m2.p_model2.runXY(0.01)\n 
    1583     print "My name is %s."% m1.name 
    1584     print out1, " = ", out2 
    1585     if out1 == out2: 
    1586         print "===> Simple Test: Passed!" 
    1587     else: 
    1588         print "===> Simple Test: Failed!" 
     1213from sasmodels.core import load_model_info 
     1214from sasmodels.sasview_model import make_model_from_info 
     1215 
     1216model_info = load_model_info('{model1}{operator}{model2}') 
     1217model_info.name = '{name}'{desc_line} 
     1218Model = make_model_from_info(model_info) 
    15891219""" 
    1590  
    15911220if __name__ == "__main__": 
    15921221#    app = wx.PySimpleApp() 
  • src/sas/sasgui/perspectives/calculator/pyconsole.py

    r7432acb r4627657  
    3737    Iqxy = model.evalDistribution([qx, qy]) 
    3838 
    39     result = """ 
    40     Iq(%s) = %s 
    41     Iqxy(%s, %s) = %s 
    42     """%(q, Iq, qx, qy, Iqxy) 
     39    # check the model's unit tests run 
     40    from sasmodels.model_test import run_one 
     41    result = run_one(path) 
    4342 
    4443    return result 
     
    8988        ok = wx.Button(self, wx.ID_OK, "OK") 
    9089 
    91         # Mysterious constraint layouts from  
     90        # Mysterious constraint layouts from 
    9291        # https://www.wxpython.org/docs/api/wx.lib.layoutf.Layoutf-class.html 
    9392        lc = layoutf.Layoutf('t=t5#1;b=t5#2;l=l5#1;r=r5#1', (self,ok)) 
  • src/sas/sasgui/perspectives/file_converter/converter_panel.py

    red9f872 r19296dc  
    2424from sas.sascalc.file_converter.otoko_loader import OTOKOLoader 
    2525from sas.sascalc.file_converter.bsl_loader import BSLLoader 
     26from sas.sascalc.file_converter.ascii2d_loader import ASCII2DLoader 
    2627from sas.sascalc.file_converter.nxcansas_writer import NXcanSASWriter 
    2728from sas.sascalc.dataloader.data_info import Detector 
     
    3536    _STATICBOX_WIDTH = 410 
    3637    _BOX_WIDTH = 200 
    37     PANEL_SIZE = 480 
     38    PANEL_SIZE = 520 
    3839    FONT_VARIANT = 0 
    3940else: 
     
    4142    _STATICBOX_WIDTH = 430 
    4243    _BOX_WIDTH = 200 
    43     PANEL_SIZE = 500 
     44    PANEL_SIZE = 540 
    4445    FONT_VARIANT = 1 
    4546 
     
    352353            w.write(frame_data, output_path) 
    353354 
     355    def convert_2d_data(self, dataset): 
     356        metadata = self.get_metadata() 
     357        for key, value in metadata.iteritems(): 
     358            setattr(dataset[0], key, value) 
     359 
     360        w = NXcanSASWriter() 
     361        w.write(dataset, self.output.GetPath()) 
     362 
    354363    def on_convert(self, event): 
    355364        """Called when the Convert button is clicked""" 
     
    367376                qdata, iqdata = self.extract_otoko_data(self.q_input.GetPath()) 
    368377                self.convert_1d_data(qdata, iqdata) 
     378            elif self.data_type == 'ascii2d': 
     379                loader = ASCII2DLoader(self.iq_input.GetPath()) 
     380                data = loader.load() 
     381                dataset = [data] # ASCII 2D only ever contains 1 frame 
     382                self.convert_2d_data(dataset) 
    369383            else: # self.data_type == 'bsl' 
    370384                dataset = self.extract_bsl_data(self.iq_input.GetPath()) 
     
    372386                    # Cancelled by user 
    373387                    return 
    374  
    375                 metadata = self.get_metadata() 
    376                 for key, value in metadata.iteritems(): 
    377                     setattr(dataset[0], key, value) 
    378  
    379                 w = NXcanSASWriter() 
    380                 w.write(dataset, self.output.GetPath()) 
     388                self.convert_2d_data(dataset) 
     389 
    381390        except Exception as ex: 
    382391            msg = str(ex) 
     
    399408    def validate_inputs(self): 
    400409        msg = "You must select a" 
    401         if self.q_input.GetPath() == '' and self.data_type != 'bsl': 
     410        if self.q_input.GetPath() == '' and self.data_type != 'bsl' \ 
     411            and self.data_type != 'ascii2d': 
    402412            msg += " Q Axis input file." 
    403413        elif self.iq_input.GetPath() == '': 
     
    472482        dtype = event.GetEventObject().GetName() 
    473483        self.data_type = dtype 
    474         if dtype == 'bsl': 
     484        if dtype == 'bsl' or dtype == 'ascii2d': 
    475485            self.q_input.SetPath("") 
    476486            self.q_input.Disable() 
     
    500510 
    501511        instructions = ( 
    502         "Select linked single column 1D ASCII files containing the Q-axis and " 
    503         "Intensity-axis data, or 1D BSL/OTOKO files, or a 2D BSL/OTOKO file, " 
    504         "then choose where to save the converted file, and click Convert.\n" 
    505         "1D ASCII and BSL/OTOKO files can be converted to CanSAS (XML) or " 
    506         "NXcanSAS (HDF5) formats. 2D BSL/OTOKO files can only be converted to " 
    507         "the NXcanSAS format.\n" 
    508         "Metadata can be optionally added for the CanSAS XML format." 
     512        "If converting a 1D dataset, select linked single-column ASCII files " 
     513        "containing the Q-axis and intensity-axis data, or a 1D BSL/OTOKO file." 
     514        " If converting 2D data, select an ASCII file in the ISIS 2D file " 
     515        "format, or a 2D BSL/OTOKO file. Choose where to save the converted " 
     516        "file and click convert.\n" 
     517        "One dimensional ASCII and BSL/OTOKO files can be converted to CanSAS " 
     518        "(XML) or NXcanSAS (HDF5) formats. Two dimensional datasets can only be" 
     519        " converted to the NXcanSAS format.\n" 
     520        "Metadata can also be optionally added to the output file." 
    509521        ) 
    510522 
     
    526538            wx.ALIGN_CENTER_VERTICAL, 5) 
    527539        radio_sizer = wx.BoxSizer(wx.HORIZONTAL) 
    528         ascii_btn = wx.RadioButton(self, -1, "ASCII", name="ascii", 
     540        ascii_btn = wx.RadioButton(self, -1, "ASCII 1D", name="ascii", 
    529541            style=wx.RB_GROUP) 
    530542        ascii_btn.Bind(wx.EVT_RADIOBUTTON, self.datatype_changed) 
    531543        radio_sizer.Add(ascii_btn) 
     544        ascii2d_btn = wx.RadioButton(self, -1, "ASCII 2D", name="ascii2d") 
     545        ascii2d_btn.Bind(wx.EVT_RADIOBUTTON, self.datatype_changed) 
     546        radio_sizer.Add(ascii2d_btn) 
    532547        otoko_btn = wx.RadioButton(self, -1, "BSL 1D", name="otoko") 
    533548        otoko_btn.Bind(wx.EVT_RADIOBUTTON, self.datatype_changed) 
    534549        radio_sizer.Add(otoko_btn) 
    535         input_grid.Add(radio_sizer, (y,1), (1,1), wx.ALL, 5) 
    536550        bsl_btn = wx.RadioButton(self, -1, "BSL 2D", name="bsl") 
    537551        bsl_btn.Bind(wx.EVT_RADIOBUTTON, self.datatype_changed) 
    538552        radio_sizer.Add(bsl_btn) 
     553        input_grid.Add(radio_sizer, (y,1), (1,1), wx.ALL, 5) 
    539554        y += 1 
    540555 
     
    549564        y += 1 
    550565 
    551         iq_label = wx.StaticText(self, -1, "Intensity-Axis Data: ") 
     566        iq_label = wx.StaticText(self, -1, "Intensity Data: ") 
    552567        input_grid.Add(iq_label, (y,0), (1,1), wx.ALIGN_CENTER_VERTICAL, 5) 
    553568 
     
    647662 
    648663    def __init__(self, parent=None, title='File Converter', base=None, 
    649         manager=None, size=(PANEL_SIZE * 1.05, PANEL_SIZE / 1.1), 
     664        manager=None, size=(PANEL_SIZE * 0.96, PANEL_SIZE * 0.9), 
    650665        *args, **kwargs): 
    651666        kwargs['title'] = title 
  • src/sas/sasgui/perspectives/file_converter/file_converter.py

    r463e7ffc r94e3572  
    2525        Returns a set of menu entries 
    2626        """ 
    27         help_txt = "Convert single column ASCII data to CanSAS format" 
     27        help_txt = "Convert ASCII or BSL/OTOKO data to CanSAS or NXcanSAS formats" 
    2828        return [("File Converter", help_txt, self.on_file_converter)] 
    2929 
  • src/sas/sasgui/perspectives/file_converter/media/file_converter_help.rst

    rd73998c r59decb81  
    1818*   Single-column ASCII data, with lines that end without any delimiter, 
    1919    or with a comma or semi-colon delimiter 
     20*   2D `ISIS ASCII formatted 
     21    <http://www.isis.stfc.ac.uk/instruments/loq/software/ 
     22    colette-ascii-file-format-descriptions9808.pdf>`_ data 
    2023*   `1D BSL/OTOKO format 
    2124    <http://www.diamond.ac.uk/Beamlines/Soft-Condensed-Matter/small-angle/ 
     
    3639 
    37401) Select the files containing your Q-axis and Intensity-axis data 
    38 2) Choose whether the files are in ASCII, 1D BSL/OTOKO or 2D BSL/OTOKO format 
     412) Choose whether the files are in ASCII 1D, ASCII 2D, 1D BSL/OTOKO or 2D BSL/OTOKO format 
    39423) Choose where you would like to save the converted file 
    40434) Optionally, input some metadata such as sample size, detector name, etc 
     
    4750file, a dialog will appear asking which frames you would like converted. You 
    4851may enter a start frame, end frame & increment, and all frames in that subset 
    49 will be converted. For example, entering 0, 50 and 10 will convert frames 0,  
     52will be converted. For example, entering 0, 50 and 10 will convert frames 0, 
    505310, 20, 30, 40 & 50. 
    5154 
     
    5659single file, so there is an option in the *Select Frame* dialog to output each 
    5760frame to its own file. The single file option will produce one file with 
    58 multiple `<SASdata>` elements. The multiple file option will output a separate  
    59 file with one `<SASdata>` element for each frame. The frame number will also be  
     61multiple `<SASdata>` elements. The multiple file option will output a separate 
     62file with one `<SASdata>` element for each frame. The frame number will also be 
    6063appended to the file name. 
    6164 
    62 The multiple file option is not available when exporting to NXcanSAS because  
     65The multiple file option is not available when exporting to NXcanSAS because 
    6366the HDF5 format is more efficient at handling large amounts of data. 
    6467 
  • src/sas/sasgui/perspectives/fitting/fitting.py

    ra534432 r2d9526d  
    257257        toks = os.path.splitext(label) 
    258258        path = os.path.join(models.find_plugins_dir(), toks[0]) 
     259        message = "Are you sure you want to delete the file {}?".format(path) 
     260        dlg = wx.MessageDialog(self.frame, message, '', wx.YES_NO | wx.ICON_QUESTION) 
     261        if not dlg.ShowModal() == wx.ID_YES: 
     262            return 
    259263        try: 
    260264            for ext in ['.py', '.pyc']: 
    261265                p_path = path + ext 
     266                if ext == '.pyc' and not os.path.isfile(path + ext): 
     267                    # If model is invalid, .pyc file may not exist as model has 
     268                    # never been compiled. Don't try and delete it 
     269                    continue 
    262270                os.remove(p_path) 
    263271            self.update_custom_combo() 
     
    361369                                   'Add a new model function') 
    362370        wx.EVT_MENU(owner, wx_id, self.make_new_model) 
    363          
     371 
    364372        wx_id = wx.NewId() 
    365373        self.edit_model_menu.Append(wx_id, 'Sum|Multi(p1, p2)', 
     
    383391          '(Re)Load all models present in user plugin_models folder') 
    384392        wx.EVT_MENU(owner, wx_id, self.load_plugin_models) 
    385                  
     393 
    386394    def set_edit_menu_helper(self, owner=None, menu=None): 
    387395        """ 
     
    17341742            @param unsmeared_error: data error, rescaled to unsmeared model 
    17351743        """ 
    1736              
    1737         number_finite = np.count_nonzero(np.isfinite(y))  
     1744        number_finite = np.count_nonzero(np.isfinite(y)) 
    17381745        np.nan_to_num(y) 
    17391746        new_plot = self.create_theory_1D(x, y, page_id, model, data, state, 
    17401747                                         data_description=model.name, 
    17411748                                         data_id=str(page_id) + " " + data.name) 
     1749        plots_to_update = [] # List of plottables that have changed since last calculation 
     1750        # Create the new theories 
    17421751        if unsmeared_model is not None: 
    1743             self.create_theory_1D(x, unsmeared_model, page_id, model, data, state, 
     1752            unsmeared_model_plot = self.create_theory_1D(x, unsmeared_model,