Changes in / [1661cd5:f15da54] in sasview


Ignore:
Files:
1 added
1 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • LICENSE.TXT

    ra3e3ef5 r7c05b63  
    1 Copyright (c) 2009-2017, SasView Developers 
     1Copyright (c) 2009-2016, SasView Developers 
    22All rights reserved. 
    33 

  • sasview/README.txt

    r311d00a r220b1e7  
    441- Features 
    55=========== 
    6     - New in Version 4.1.0 
    7       ------------------ 
    8       This incremental release brings a series of new features and improvements, 
    9       and a host of bug fixes. Of particular note are: 
    10        
    11       - Correlation Function Analysis (Corfunc) 
    12         This performs a correlation function analysis of one-dimensional SAXS/SANS data,  
    13         or generates a model-independent volume fraction profile from the SANS from an  
    14         adsorbed polymer/surfactant layer. 
    15  
    16         A correlation function may be interpreted in terms of an imaginary rod moving  
    17         through the structure of the material. Γ1D(R) is the probability that a rod of  
    18         length R moving through the material has equal electron/neutron scattering  
    19         length density at either end. Hence a frequently occurring spacing within a  
    20         structure manifests itself as a peak. 
    21  
    22         A volume fraction profile \Phi(z) describes how the density of polymer  
    23         segments/surfactant molecules varies with distance from an (assumed locally flat) 
    24         interface. 
    25  
    26       - Fitting of SESANS Data 
    27         Data from Spin-Echo SANS measurements can now be loaded and fitted. The data will  
    28         be plotted against the correct axes and models will automatically perform a Hankel  
    29         transform in order to calculate SESANS from a SANS model. 
    30  
    31       - Documentation 
    32         The documentation has undergone significant checking and updating. 
    33  
    34       - Improvements 
    35         - Correlation function (corfunc) analysis of 1D SAS data added from CCP13 
    36         - File converter tool for multi-file single column data sets 
    37         - SESANS data loading and direct fitting using the Hankel transformation 
    38         - Saving and loading of simultaneous and constrained fits now supported 
    39         - Save states from SasView v3.x.y now loaded using sasmodel model names 
    40         - Saving and loading of projects with 2D fits now supported 
    41         - Loading a project removes all existing data, fits, and plots 
    42         - Structure factor and form factor can be plotted independently 
    43         - OpenCL is disabled by default and can be enabled through a fit menu 
    44         - Data and theory fields are now independently expandable 
    45       - Bug Fixes 
    46         - Fixes #667: Models computed multiple times on parameters changes 
    47         - Fixes #673: Custom models override built in models of same name 
    48         - Fixes #678: Hard crash when running complex models on GPU 
    49         - Fixes $774: Old style plugin models unloadable 
    50         - Fixes #789: stacked disk scale doesn't match cylinder model 
    51         - Fixes #792: core_shell_fractal uses wrong effective radius 
    52         - Fixes #800: Plot range reset on plot redraws 
    53         - Fixes #811 and #825: 2D smearing broken 
    54         - Fixes #815: Integer model parameter handling 
    55         - Fixes #824: Cannot apply sector averaging when no detector data present 
    56         - Fixes #830: Cansas HDF5 reader fully compliant with NXCanSAS v1.0 format 
    57         - Fixes #835: Fractal model breaks with negative Q values 
    58         - Fixes #843: Multilayer vesicle does not define effective radius 
    59         - Fixes #858: Hayter MSA S(Q) returns errors 
    60         - Numerous grammatical and contexual errors in documention 
    61  
    62  
    636    - New in Version 4.0.1 
    647      ------------------ 
    … …  
    483426=============== 
    484427 
    485  
    486    4.1- All systems: 
    487       The conversion to sasmodels infrastructure is ongoing and should be 
    488       completed in the next release. In the meantime this leads to a few known 
    489       issues: 
    490         - The way that orientation is defined is being refactored to address 
    491         long standing issues and comments.  In release 4.1 however only models 
    492         with symmetry (e.g. a=b) have been converted to the new definitions. 
    493         The rest (a <> b <> c - e.g. parellelepiped) maintain the same 
    494         definition as before and will be converted in 4.2.  Note that 
    495         orientational distribution also makes much more sense in the new 
    496         framework.  The documentation should indicate which definition is being 
    497         used for a given model. 
    498         - The infrastructure currently handles internal conversion of old style 
    499         models so that user created models in previous versions should continue 
    500         to work for now. At some point in the future such support will go away. 
    501         Everyone is encouraged to convert to the new structure which should be 
    502         relatively straight forward and provides a number of benefits.  
    503         - In that vein, the distributed models and those generated by the new 
    504         plugin model editor are in the new format, however those generated by 
    505         sum|multiply models are the old style sum|multiply models. This should 
    506         also disappear in the near future  
    507         - The on the fly discovery of plugin models and changes thereto behave 
    508         inconsistently.  If a change to a plugin model does not seem to 
    509         register, the Load Plugin Models (under fitting -> Plugin Model 
    510         Operations) can be used.  However, after calling Load Plugin Models, the 
    511         active plugin will no longer be loaded (even though the GUI looks like 
    512         it is) unless it is a sum|multiply model which works properly.  All 
    513         others will need to be recalled from the model dropdown menu to reload 
    514         the model into the calculation engine.  While it might be annoying it 
    515         does not appear to prevent SasView from working.. 
    516         - The model code and documentation review is ongoing. At this time the 
    517         core shell parellelepiped is known to have the C shell effectively fixed 
    518         at 0 (noted in documentation) while the triaxial ellipsoid does not seem 
    519         to reproduce the limit of the oblate or prolate ellipsoid. If errors are 
    520         found and corrected, corrected versions will be uploaded to the 
    521         marketplace.  
    522     
    523428   3.1- All systems: 
    524429        - The documentation window may take a few seconds to load the first time 

  • sasview/local_config.py

    rf9d1f60 r73cbeec  
    3333''' remember to:''' 
    3434_acknowledgement_preamble_bullet1 =\ 
    35 '''Acknowledge its use in your publications as :''' 
     35'''Acknowledge its use in your publications as suggested below;''' 
    3636_acknowledgement_preamble_bullet2 =\ 
    37 '''Reference SasView as:''' 
     37'''Reference SasView as : M. Doucet, et al. SasView Version 4.0, Zenodo''' +\ 
     38''', http://doi.org/10.5281/zenodo.159083;''' 
    3839_acknowledgement_preamble_bullet3 =\ 
    39 '''Reference the model you used if appropriate (see documentation for refs)''' 
     40'''Reference the model you used if appropriate (see documentation for refs);''' 
    4041_acknowledgement_preamble_bullet4 =\ 
    4142'''Send us your reference for our records: developers@sasview.org''' 
    4243_acknowledgement_publications = \ 
    43 '''This work benefited from the use of the SasView application, originally developed under NSF Award DMR-0520547. SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project Grant No 654000.''' 
    44 _acknowledgement_citation = \ 
    45 '''M. Doucet et al. SasView Version 4.1, Zenodo, 10.5281/zenodo.438138''' 
     44'''This work benefited from the use of the SasView application, originally developed under NSF Award  
     45DMR-0520547. SasView also contains code developed with funding from the EU Horizon 2020 programme  
     46under the SINE2020 project Grant No 654000, and by Patrick O'Brien & Adam Washington.''' 
    4647 
    4748_acknowledgement =  \ 
    48 '''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: https://github.com/orgs/SasView/people 
    49 ''' 
     49'''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547, but is currently maintained  
     50by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft. SasView also contains code developed with funding from the  
     51EU Horizon 2020 programme under the SINE2020 project (Grant No 654000), and by Patrick O'Brien (pycrust) and Adam Washington (corfunc-py).''' 
    5052 
    5153_homepage = "http://www.sasview.org" 
    … …  
    8789_corner_image = os.path.join(icon_path, "angles_flat.png") 
    8890_welcome_image = os.path.join(icon_path, "SVwelcome.png") 
    89 _copyright = "(c) 2009 - 2017, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft" 
     91_copyright = "(c) 2009 - 2016, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft" 
    9092marketplace_url = "http://marketplace.sasview.org/" 
    9193 

  • setup.py

    r27109e5 r1e13b53  
    315315                               'test/1d_data/*', 
    316316                               'test/2d_data/*', 
    317                                'test/convertible_files/*', 
    318                                'test/coordinate_data/*', 
    319                                'test/image_data/*', 
    320                                'test/media/*', 
    321                                'test/other_files/*', 
    322317                               'test/save_states/*', 
    323                                'test/sesans_data/*' 
    324                                ] 
     318                               'test/upcoming_formats/*', 
     319                                 'default_categories.json'] 
    325320packages.append("sas.sasview") 
    326321 

  • src/sas/sascalc/calculator/slit_length_calculator.py

    rbfba720 rb699768  
    1616        # y data 
    1717        self.y = None 
    18         # default slit length 
     18        #default slit length 
    1919        self.slit_length = 0.0 
    2020 
    … …  
    4242        """ 
    4343        # None data do nothing 
    44         if self.y is None or self.x is None: 
     44        if self.y == None or self.x == None: 
    4545            return 
    4646        # set local variable 
    … …  
    5454        y_sum = 0.0 
    5555        y_max = 0.0 
    56         ind = 0 
     56        ind = 0.0 
    5757 
    5858        # sum 10 or more y values until getting max_y, 
    … …  
    7070        # defaults 
    7171        y_half_d = 0.0 
    72         ind = 0 
     72        ind = 0.0 
    7373        # find indices where it crosses y = y_half. 
    7474        while True: 
    … …  
    8181 
    8282        # y value and ind just before passed the spot of the half height 
    83         y_half_u = y[ind - 1] 
     83        y_half_u = y[ind-1] 
    8484 
    8585        # get corresponding x values 
    8686        x_half_d = x[ind] 
    87         x_half_u = x[ind - 1] 
     87        x_half_u = x[ind-1] 
    8888 
    8989        # calculate x at y = y_half using linear interpolation 
    … …  
    9191            x_half = (x_half_d + x_half_u)/2.0 
    9292        else: 
    93             x_half = ((x_half_u * (y_half - y_half_d) 
    94                        + x_half_d * (y_half_u - y_half)) 
    95                        / (y_half_u - y_half_d)) 
     93            x_half = (x_half_u * (y_half - y_half_d)  \ 
     94                       + x_half_d * (y_half_u - y_half)) \ 
     95                        / (y_half_u - y_half_d) 
    9696 
    9797        # Our slit length is half width, so just give half beam value 

  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    r8434365 rc221349  
    930930            self._write_data(datainfo, entry_node) 
    931931        # Transmission Spectrum Info 
    932         # TODO: fix the writer to linearize all data, including T_spectrum 
    933         # self._write_trans_spectrum(datainfo, entry_node) 
     932        self._write_trans_spectrum(datainfo, entry_node) 
    934933        # Sample info 
    935934        self._write_sample_info(datainfo, entry_node) 

  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    rc94280c rbbd0f37  
    99import sys 
    1010 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D,\ 
    12     Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \ 
    13     TransmissionSpectrum, Detector 
     11from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D, Data1D, Data2D, DataInfo, Process, Aperture 
     12from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, Detector 
    1413from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable 
     14 
    1515 
    1616 
    1717class Reader(): 
    1818    """ 
    19     A class for reading in CanSAS v2.0 data files. The existing iteration opens 
    20     Mantid generated HDF5 formatted files with file extension .h5/.H5. Any 
    21     number of data sets may be present within the file and any dimensionality 
    22     of data may be used. Currently 1D and 2D SAS data sets are supported, but 
    23     future implementations will include 1D and 2D SESANS data. 
    24  
    25     Any number of SASdata sets may be present in a SASentry and the data within 
    26     can be either 1D I(Q) or 2D I(Qx, Qy). 
     19    A class for reading in CanSAS v2.0 data files. The existing iteration opens Mantid generated HDF5 formatted files 
     20    with file extension .h5/.H5. Any number of data sets may be present within the file and any dimensionality of data 
     21    may be used. Currently 1D and 2D SAS data sets are supported, but future implementations will include 1D and 2D 
     22    SESANS data. 
     23 
     24    Any number of SASdata sets may be present in a SASentry and the data within can be either 1D I(Q) or 2D I(Qx, Qy). 
    2725 
    2826    Also supports reading NXcanSAS formatted HDF5 files 
    … …  
    3230    """ 
    3331 
    34     # CanSAS version 
     32    ## CanSAS version 
    3533    cansas_version = 2.0 
    36     # Logged warnings or messages 
     34    ## Logged warnings or messages 
    3735    logging = None 
    38     # List of errors for the current data set 
     36    ## List of errors for the current data set 
    3937    errors = None 
    40     # Raw file contents to be processed 
     38    ## Raw file contents to be processed 
    4139    raw_data = None 
    42     # Data info currently being read in 
     40    ## Data info currently being read in 
    4341    current_datainfo = None 
    44     # SASdata set currently being read in 
     42    ## SASdata set currently being read in 
    4543    current_dataset = None 
    46     # List of plottable1D objects that should be linked to the current_datainfo 
     44    ## List of plottable1D objects that should be linked to the current_datainfo 
    4745    data1d = None 
    48     # List of plottable2D objects that should be linked to the current_datainfo 
     46    ## List of plottable2D objects that should be linked to the current_datainfo 
    4947    data2d = None 
    50     # Data type name 
     48    ## Data type name 
    5149    type_name = "CanSAS 2.0" 
    52     # Wildcards 
     50    ## Wildcards 
    5351    type = ["CanSAS 2.0 HDF5 Files (*.h5)|*.h5"] 
    54     # List of allowed extensions 
     52    ## List of allowed extensions 
    5553    ext = ['.h5', '.H5'] 
    56     # Flag to bypass extension check 
    57     allow_all = True 
    58     # List of files to return 
     54    ## Flag to bypass extension check 
     55    allow_all = False 
     56    ## List of files to return 
    5957    output = None 
    6058 
    … …  
    6664        :return: List of Data1D/2D objects and/or a list of errors. 
    6765        """ 
    68         # Reinitialize when loading a new data file to reset all class variables 
     66        ## Reinitialize the class when loading a new data file to reset all class variables 
    6967        self.reset_class_variables() 
    70         # Check that the file exists 
     68        ## Check that the file exists 
    7169        if os.path.isfile(filename): 
    7270            basename = os.path.basename(filename) 
    … …  
    7472            # If the file type is not allowed, return empty list 
    7573            if extension in self.ext or self.allow_all: 
    76                 # Load the data file 
     74                ## Load the data file 
    7775                self.raw_data = h5py.File(filename, 'r') 
    78                 # Read in all child elements of top level SASroot 
     76                ## Read in all child elements of top level SASroot 
    7977                self.read_children(self.raw_data, []) 
    80                 # Add the last data set to the list of outputs 
     78                ## Add the last data set to the list of outputs 
    8179                self.add_data_set() 
    82                 # Close the data file 
     80                ## Close the data file 
    8381                self.raw_data.close() 
    84         # Return data set(s) 
     82        ## Return data set(s) 
    8583        return self.output 
    8684 
    … …  
    112110        """ 
    113111 
    114         # Loop through each element of the parent and process accordingly 
     112        ## Loop through each element of the parent and process accordingly 
    115113        for key in data.keys(): 
    116             # Get all information for the current key 
     114            ## Get all information for the current key 
    117115            value = data.get(key) 
    118116            if value.attrs.get(u'canSAS_class') is not None: 
    … …  
    128126                self.parent_class = class_name 
    129127                parent_list.append(key) 
    130                 # If a new sasentry, store the current data sets and create 
    131                 # a fresh Data1D/2D object 
     128                ## If this is a new sasentry, store the current data sets and create a fresh Data1D/2D object 
    132129                if class_prog.match(u'SASentry'): 
    133130                    self.add_data_set(key) 
    134131                elif class_prog.match(u'SASdata'): 
    135132                    self._initialize_new_data_set(parent_list) 
    136                 # Recursion step to access data within the group 
     133                ## Recursion step to access data within the group 
    137134                self.read_children(value, parent_list) 
    138135                self.add_intermediate() 
    … …  
    140137 
    141138            elif isinstance(value, h5py.Dataset): 
    142                 # If this is a dataset, store the data appropriately 
     139                ## If this is a dataset, store the data appropriately 
    143140                data_set = data[key][:] 
    144141                unit = self._get_unit(value) 
    145142 
    146                 # I and Q Data 
     143                ## I and Q Data 
    147144                if key == u'I': 
    148                     if isinstance(self.current_dataset, plottable_2D): 
     145                    if type(self.current_dataset) is plottable_2D: 
    149146                        self.current_dataset.data = data_set 
    150147                        self.current_dataset.zaxis("Intensity", unit) 
    … …  
    154151                    continue 
    155152                elif key == u'Idev': 
    156                     if isinstance(self.current_dataset, plottable_2D): 
     153                    if type(self.current_dataset) is plottable_2D: 
    157154                        self.current_dataset.err_data = data_set.flatten() 
    158155                    else: 
    … …  
    161158                elif key == u'Q': 
    162159                    self.current_dataset.xaxis("Q", unit) 
    163                     if isinstance(self.current_dataset, plottable_2D): 
     160                    if type(self.current_dataset) is plottable_2D: 
    164161                        self.current_dataset.q = data_set.flatten() 
    165162                    else: 
    … …  
    169166                    self.current_dataset.dx = data_set.flatten() 
    170167                    continue 
    171                 elif key == u'dQw': 
    172                     self.current_dataset.dxw = data_set.flatten() 
    173                     continue 
    174                 elif key == u'dQl': 
    175                     self.current_dataset.dxl = data_set.flatten() 
    176                     continue 
    177168                elif key == u'Qy': 
    178169                    self.current_dataset.yaxis("Q_y", unit) 
    … …  
    192183                    self.current_dataset.mask = data_set.flatten() 
    193184                    continue 
    194                 # Transmission Spectrum 
    195                 elif (key == u'T' 
    196                       and self.parent_class == u'SAStransmission_spectrum'): 
    197                     self.trans_spectrum.transmission = data_set.flatten() 
    198                     continue 
    199                 elif (key == u'Tdev' 
    200                       and self.parent_class == u'SAStransmission_spectrum'): 
    201                     self.trans_spectrum.transmission_deviation = \ 
    202                         data_set.flatten() 
    203                     continue 
    204                 elif (key == u'lambda' 
    205                       and self.parent_class == u'SAStransmission_spectrum'): 
    206                     self.trans_spectrum.wavelength = data_set.flatten() 
    207                     continue 
    208185 
    209186                for data_point in data_set: 
    210                     # Top Level Meta Data 
     187                    ## Top Level Meta Data 
    211188                    if key == u'definition': 
    212189                        self.current_datainfo.meta_data['reader'] = data_point 
    … …  
    224201                        self.current_datainfo.notes.append(data_point) 
    225202 
    226                     # Sample Information 
    227                     # CanSAS 2.0 format 
    228                     elif key == u'Title' and self.parent_class == u'SASsample': 
     203                    ## Sample Information 
     204                    elif key == u'Title' and self.parent_class == u'SASsample': # CanSAS 2.0 format 
    229205                        self.current_datainfo.sample.name = data_point 
    230                     # NXcanSAS format 
    231                     elif key == u'name' and self.parent_class == u'SASsample': 
     206                    elif key == u'ID' and self.parent_class == u'SASsample': # NXcanSAS format 
    232207                        self.current_datainfo.sample.name = data_point 
    233                     # NXcanSAS format 
    234                     elif key == u'ID' and self.parent_class == u'SASsample': 
    235                         self.current_datainfo.sample.name = data_point 
    236                     elif (key == u'thickness' 
    237                           and self.parent_class == u'SASsample'): 
     208                    elif key == u'thickness' and self.parent_class == u'SASsample': 
    238209                        self.current_datainfo.sample.thickness = data_point 
    239                     elif (key == u'temperature' 
    240                           and self.parent_class == u'SASsample'): 
     210                    elif key == u'temperature' and self.parent_class == u'SASsample': 
    241211                        self.current_datainfo.sample.temperature = data_point 
    242                     elif (key == u'transmission' 
    243                           and self.parent_class == u'SASsample'): 
     212                    elif key == u'transmission' and self.parent_class == u'SASsample': 
    244213                        self.current_datainfo.sample.transmission = data_point 
    245                     elif (key == u'x_position' 
    246                           and self.parent_class == u'SASsample'): 
     214                    elif key == u'x_position' and self.parent_class == u'SASsample': 
    247215                        self.current_datainfo.sample.position.x = data_point 
    248                     elif (key == u'y_position' 
    249                           and self.parent_class == u'SASsample'): 
     216                    elif key == u'y_position' and self.parent_class == u'SASsample': 
    250217                        self.current_datainfo.sample.position.y = data_point 
    251                     elif key == u'pitch' and self.parent_class == u'SASsample': 
     218                    elif key == u'polar_angle' and self.parent_class == u'SASsample': 
    252219                        self.current_datainfo.sample.orientation.x = data_point 
    253                     elif key == u'yaw' and self.parent_class == u'SASsample': 
    254                         self.current_datainfo.sample.orientation.y = data_point 
    255                     elif key == u'roll' and self.parent_class == u'SASsample': 
     220                    elif key == u'azimuthal_angle' and self.parent_class == u'SASsample': 
    256221                        self.current_datainfo.sample.orientation.z = data_point 
    257                     elif (key == u'details' 
    258                           and self.parent_class == u'SASsample'): 
     222                    elif key == u'details' and self.parent_class == u'SASsample': 
    259223                        self.current_datainfo.sample.details.append(data_point) 
    260224 
    261                     # Instrumental Information 
    262                     elif (key == u'name' 
    263                           and self.parent_class == u'SASinstrument'): 
     225                    ## Instrumental Information 
     226                    elif key == u'name' and self.parent_class == u'SASinstrument': 
    264227                        self.current_datainfo.instrument = data_point 
    265228                    elif key == u'name' and self.parent_class == u'SASdetector': 
    … …  
    268231                        self.detector.distance = float(data_point) 
    269232                        self.detector.distance_unit = unit 
    270                     elif (key == u'slit_length' 
    271                           and self.parent_class == u'SASdetector'): 
     233                    elif key == u'slit_length' and self.parent_class == u'SASdetector': 
    272234                        self.detector.slit_length = float(data_point) 
    273235                        self.detector.slit_length_unit = unit 
    274                     elif (key == u'x_position' 
    275                           and self.parent_class == u'SASdetector'): 
     236                    elif key == u'x_position' and self.parent_class == u'SASdetector': 
    276237                        self.detector.offset.x = float(data_point) 
    277238                        self.detector.offset_unit = unit 
    278                     elif (key == u'y_position' 
    279                           and self.parent_class == u'SASdetector'): 
     239                    elif key == u'y_position' and self.parent_class == u'SASdetector': 
    280240                        self.detector.offset.y = float(data_point) 
    281241                        self.detector.offset_unit = unit 
    282                     elif (key == u'pitch' 
    283                           and self.parent_class == u'SASdetector'): 
     242                    elif key == u'polar_angle' and self.parent_class == u'SASdetector': 
    284243                        self.detector.orientation.x = float(data_point) 
    285244                        self.detector.orientation_unit = unit 
    286                     elif key == u'roll' and self.parent_class == u'SASdetector': 
     245                    elif key == u'azimuthal_angle' and self.parent_class == u'SASdetector': 
    287246                        self.detector.orientation.z = float(data_point) 
    288247                        self.detector.orientation_unit = unit 
    289                     elif key == u'yaw' and self.parent_class == u'SASdetector': 
    290                         self.detector.orientation.y = float(data_point) 
    291                         self.detector.orientation_unit = unit 
    292                     elif (key == u'beam_center_x' 
    293                           and self.parent_class == u'SASdetector'): 
     248                    elif key == u'beam_center_x' and self.parent_class == u'SASdetector': 
    294249                        self.detector.beam_center.x = float(data_point) 
    295250                        self.detector.beam_center_unit = unit 
    296                     elif (key == u'beam_center_y' 
    297                           and self.parent_class == u'SASdetector'): 
     251                    elif key == u'beam_center_y' and self.parent_class == u'SASdetector': 
    298252                        self.detector.beam_center.y = float(data_point) 
    299253                        self.detector.beam_center_unit = unit 
    300                     elif (key == u'x_pixel_size' 
    301                           and self.parent_class == u'SASdetector'): 
     254                    elif key == u'x_pixel_size' and self.parent_class == u'SASdetector': 
    302255                        self.detector.pixel_size.x = float(data_point) 
    303256                        self.detector.pixel_size_unit = unit 
    304                     elif (key == u'y_pixel_size' 
    305                           and self.parent_class == u'SASdetector'): 
     257                    elif key == u'y_pixel_size' and self.parent_class == u'SASdetector': 
    306258                        self.detector.pixel_size.y = float(data_point) 
    307259                        self.detector.pixel_size_unit = unit 
    308                     elif (key == u'distance' 
    309                           and self.parent_class == u'SAScollimation'): 
     260                    elif key == u'SSD' and self.parent_class == u'SAScollimation': 
    310261                        self.collimation.length = data_point 
    311262                        self.collimation.length_unit = unit 
    312                     elif (key == u'name' 
    313                           and self.parent_class == u'SAScollimation'): 
     263                    elif key == u'name' and self.parent_class == u'SAScollimation': 
    314264                        self.collimation.name = data_point 
    315                     elif (key == u'shape' 
    316                           and self.parent_class == u'SASaperture'): 
    317                         self.aperture.shape = data_point 
    318                     elif (key == u'x_gap' 
    319                           and self.parent_class == u'SASaperture'): 
    320                         self.aperture.size.x = data_point 
    321                     elif (key == u'y_gap' 
    322                           and self.parent_class == u'SASaperture'): 
    323                         self.aperture.size.y = data_point 
    324  
    325                     # Process Information 
    326                     elif (key == u'Title' 
    327                           and self.parent_class == u'SASprocess'): # CanSAS 2.0 
     265 
     266                    ## Process Information 
     267                    elif key == u'name' and self.parent_class == u'SASprocess': 
    328268                        self.process.name = data_point 
    329                     elif (key == u'name' 
    330                           and self.parent_class == u'SASprocess'): # NXcanSAS 
     269                    elif key == u'Title' and self.parent_class == u'SASprocess': # CanSAS 2.0 format 
    331270                        self.process.name = data_point 
    332                     elif (key == u'description' 
    333                           and self.parent_class == u'SASprocess'): 
     271                    elif key == u'name' and self.parent_class == u'SASprocess': # NXcanSAS format 
     272                        self.process.name = data_point 
     273                    elif key == u'description' and self.parent_class == u'SASprocess': 
    334274                        self.process.description = data_point 
    335275                    elif key == u'date' and self.parent_class == u'SASprocess': 
    336276                        self.process.date = data_point 
    337                     elif key == u'term' and self.parent_class == u'SASprocess': 
    338                         self.process.term = data_point 
    339277                    elif self.parent_class == u'SASprocess': 
    340278                        self.process.notes.append(data_point) 
    341279 
    342                     # Source 
    343                     elif (key == u'wavelength' 
    344                           and self.parent_class == u'SASdata'): 
     280                    ## Transmission Spectrum 
     281                    elif key == u'T' and self.parent_class == u'SAStransmission_spectrum': 
     282                        self.trans_spectrum.transmission.append(data_point) 
     283                    elif key == u'Tdev' and self.parent_class == u'SAStransmission_spectrum': 
     284                        self.trans_spectrum.transmission_deviation.append(data_point) 
     285                    elif key == u'lambda' and self.parent_class == u'SAStransmission_spectrum': 
     286                        self.trans_spectrum.wavelength.append(data_point) 
     287 
     288                    ## Source 
     289                    elif key == u'wavelength' and self.parent_class == u'SASdata': 
    345290                        self.current_datainfo.source.wavelength = data_point 
    346291                        self.current_datainfo.source.wavelength_unit = unit 
    347                     elif (key == u'incident_wavelength' 
    348                           and self.parent_class == 'SASsource'): 
     292                    elif key == u'incident_wavelength' and self.parent_class == u'SASsource': 
    349293                        self.current_datainfo.source.wavelength = data_point 
    350294                        self.current_datainfo.source.wavelength_unit = unit 
    351                     elif (key == u'wavelength_max' 
    352                           and self.parent_class == u'SASsource'): 
     295                    elif key == u'wavelength_max' and self.parent_class == u'SASsource': 
    353296                        self.current_datainfo.source.wavelength_max = data_point 
    354297                        self.current_datainfo.source.wavelength_max_unit = unit 
    355                     elif (key == u'wavelength_min' 
    356                           and self.parent_class == u'SASsource'): 
     298                    elif key == u'wavelength_min' and self.parent_class == u'SASsource': 
    357299                        self.current_datainfo.source.wavelength_min = data_point 
    358300                        self.current_datainfo.source.wavelength_min_unit = unit 
    359                     elif (key == u'incident_wavelength_spread' 
    360                           and self.parent_class == u'SASsource'): 
    361                         self.current_datainfo.source.wavelength_spread = \ 
    362                             data_point 
    363                         self.current_datainfo.source.wavelength_spread_unit = \ 
    364                             unit 
    365                     elif (key == u'beam_size_x' 
    366                           and self.parent_class == u'SASsource'): 
     301                    elif key == u'wavelength_spread' and self.parent_class == u'SASsource': 
     302                        self.current_datainfo.source.wavelength_spread = data_point 
     303                        self.current_datainfo.source.wavelength_spread_unit = unit 
     304                    elif key == u'beam_size_x' and self.parent_class == u'SASsource': 
    367305                        self.current_datainfo.source.beam_size.x = data_point 
    368306                        self.current_datainfo.source.beam_size_unit = unit 
    369                     elif (key == u'beam_size_y' 
    370                           and self.parent_class == u'SASsource'): 
     307                    elif key == u'beam_size_y' and self.parent_class == u'SASsource': 
    371308                        self.current_datainfo.source.beam_size.y = data_point 
    372309                        self.current_datainfo.source.beam_size_unit = unit 
    373                     elif (key == u'beam_shape' 
    374                           and self.parent_class == u'SASsource'): 
     310                    elif key == u'beam_shape' and self.parent_class == u'SASsource': 
    375311                        self.current_datainfo.source.beam_shape = data_point 
    376                     elif (key == u'radiation' 
    377                           and self.parent_class == u'SASsource'): 
     312                    elif key == u'radiation' and self.parent_class == u'SASsource': 
    378313                        self.current_datainfo.source.radiation = data_point 
    379                     elif (key == u'transmission' 
    380                           and self.parent_class == u'SASdata'): 
     314                    elif key == u'transmission' and self.parent_class == u'SASdata': 
    381315                        self.current_datainfo.sample.transmission = data_point 
    382316 
    383                     # Everything else goes in meta_data 
     317                    ## Everything else goes in meta_data 
    384318                    else: 
    385                         new_key = self._create_unique_key( 
    386                             self.current_datainfo.meta_data, key) 
     319                        new_key = self._create_unique_key(self.current_datainfo.meta_data, key) 
    387320                        self.current_datainfo.meta_data[new_key] = data_point 
    388321 
    389322            else: 
    390                 # I don't know if this reachable code 
     323                ## I don't know if this reachable code 
    391324                self.errors.add("ShouldNeverHappenException") 
    392325 
    393326    def add_intermediate(self): 
    394327        """ 
    395         This method stores any intermediate objects within the final data set 
    396         after fully reading the set. 
    397  
    398         :param parent: The NXclass name for the h5py Group object that just 
    399                        finished being processed 
     328        This method stores any intermediate objects within the final data set after fully reading the set. 
     329 
     330        :param parent: The NXclass name for the h5py Group object that just finished being processed 
    400331        """ 
    401332 
    … …  
    416347            self.aperture = Aperture() 
    417348        elif self.parent_class == u'SASdata': 
    418             if isinstance(self.current_dataset, plottable_2D): 
     349            if type(self.current_dataset) is plottable_2D: 
    419350                self.data2d.append(self.current_dataset) 
    420             elif isinstance(self.current_dataset, plottable_1D): 
     351            elif type(self.current_dataset) is plottable_1D: 
    421352                self.data1d.append(self.current_dataset) 
    422353 
    423354    def final_data_cleanup(self): 
    424355        """ 
    425         Does some final cleanup and formatting on self.current_datainfo and 
    426         all data1D and data2D objects and then combines the data and info into 
    427         Data1D and Data2D objects 
    428         """ 
    429  
    430         # Type cast data arrays to float64 
     356        Does some final cleanup and formatting on self.current_datainfo and all data1D and data2D objects and then 
     357        combines the data and info into Data1D and Data2D objects 
     358        """ 
     359 
     360        ## Type cast data arrays to float64 
    431361        if len(self.current_datainfo.trans_spectrum) > 0: 
    432362            spectrum_list = [] 
    … …  
    434364                spectrum.transmission = np.delete(spectrum.transmission, [0]) 
    435365                spectrum.transmission = spectrum.transmission.astype(np.float64) 
    436                 spectrum.transmission_deviation = np.delete( 
    437                     spectrum.transmission_deviation, [0]) 
    438                 spectrum.transmission_deviation = \ 
    439                     spectrum.transmission_deviation.astype(np.float64) 
     366                spectrum.transmission_deviation = np.delete(spectrum.transmission_deviation, [0]) 
     367                spectrum.transmission_deviation = spectrum.transmission_deviation.astype(np.float64) 
    440368                spectrum.wavelength = np.delete(spectrum.wavelength, [0]) 
    441369                spectrum.wavelength = spectrum.wavelength.astype(np.float64) 
    … …  
    444372            self.current_datainfo.trans_spectrum = spectrum_list 
    445373 
    446         # Append errors to dataset and reset class errors 
     374        ## Append errors to dataset and reset class errors 
    447375        self.current_datainfo.errors = self.errors 
    448376        self.errors.clear() 
    449377 
    450         # Combine all plottables with datainfo and append each to output 
    451         # Type cast data arrays to float64 and find min/max as appropriate 
     378        ## Combine all plottables with datainfo and append each to output 
     379        ## Type cast data arrays to float64 and find min/max as appropriate 
    452380        for dataset in self.data2d: 
    453381            dataset.data = dataset.data.astype(np.float64) 
    … …  
    469397            zeros = np.ones(dataset.data.size, dtype=bool) 
    470398            try: 
    471                 for i in range(0, dataset.mask.size - 1): 
     399                for i in range (0, dataset.mask.size - 1): 
    472400                    zeros[i] = dataset.mask[i] 
    473401            except: 
    474402                self.errors.add(sys.exc_value) 
    475403            dataset.mask = zeros 
    476             # Calculate the actual Q matrix 
     404            ## Calculate the actual Q matrix 
    477405            try: 
    478406                if dataset.q_data.size <= 1: 
    479                     dataset.q_data = np.sqrt(dataset.qx_data 
    480                                              * dataset.qx_data 
    481                                              + dataset.qy_data 
    482                                              * dataset.qy_data) 
     407                    dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data + dataset.qy_data * dataset.qy_data) 
    483408            except: 
    484409                dataset.q_data = None 
    … …  
    490415                dataset.data = dataset.data.flatten() 
    491416 
    492             final_dataset = combine_data_info_with_plottable( 
    493                 dataset, self.current_datainfo) 
     417            final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo) 
    494418            self.output.append(final_dataset) 
    495419 
    … …  
    511435            if dataset.dy is not None: 
    512436                dataset.dy = dataset.dy.astype(np.float64) 
    513             final_dataset = combine_data_info_with_plottable( 
    514                 dataset, self.current_datainfo) 
     437            final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo) 
    515438            self.output.append(final_dataset) 
    516439 
    517440    def add_data_set(self, key=""): 
    518441        """ 
    519         Adds the current_dataset to the list of outputs after preforming final 
    520         processing on the data and then calls a private method to generate a 
    521         new data set. 
     442        Adds the current_dataset to the list of outputs after preforming final processing on the data and then calls a 
     443        private method to generate a new data set. 
    522444 
    523445        :param key: NeXus group name for current tree level 
    … …  
    531453 
    532454 
    533     def _initialize_new_data_set(self, parent_list=None): 
    534         """ 
    535         A private class method to generate a new 1D or 2D data object based on 
    536         the type of data within the set. Outside methods should call 
    537         add_data_set() to be sure any existing data is stored properly. 
     455    def _initialize_new_data_set(self, parent_list = None): 
     456        """ 
     457        A private class method to generate a new 1D or 2D data object based on the type of data within the set. 
     458        Outside methods should call add_data_set() to be sure any existing data is stored properly. 
    538459 
    539460        :param parent_list: List of names of parent elements 
    … …  
    552473    def _find_intermediate(self, parent_list, basename=""): 
    553474        """ 
    554         A private class used to find an entry by either using a direct key or 
    555         knowing the approximate basename. 
    556  
    557         :param parent_list: List of parents nodes in the HDF5 file 
     475        A private class used to find an entry by either using a direct key or knowing the approximate basename. 
     476 
     477        :param parent_list: List of parents to the current level in the HDF5 file 
    558478        :param basename: Approximate name of an entry to search for 
    559479        :return: 
    … …  
    566486            top = top.get(parent) 
    567487        for key in top.keys(): 
    568             if key_prog.match(key): 
     488            if (key_prog.match(key)): 
    569489                entry = True 
    570490                break 
    … …  
    596516        """ 
    597517        unit = value.attrs.get(u'units') 
    598         if unit is None: 
     518        if unit == None: 
    599519            unit = value.attrs.get(u'unit') 
    600         # Convert the unit formats 
     520        ## Convert the unit formats 
    601521        if unit == "1/A": 
    602522            unit = "A^{-1}" 

  • src/sas/sascalc/fit/BumpsFitting.py

    r1a30720 r345e7e4  
    352352    except Exception as exc: 
    353353        best, fbest = None, numpy.NaN 
    354         errors = [str(exc), traceback.format_exc()] 
     354        errors = [str(exc), traceback.traceback.format_exc()] 
    355355    finally: 
    356356        mapper.stop_mapper(fitdriver.mapper) 

  • src/sas/sasgui/guiframe/acknowledgebox.py

    r74c8cd0 rc1fdf84  
    1111import wx.richtext 
    1212import wx.lib.hyperlink 
    13 from wx.lib.expando import ExpandoTextCtrl 
    1413import random 
    1514import os.path 
    … …  
    3736    Shows the current method for acknowledging SasView in 
    3837    scholarly publications. 
     38 
    3939    """ 
    4040 
    … …  
    4444        wx.Dialog.__init__(self, *args, **kwds) 
    4545 
    46         self.ack = ExpandoTextCtrl(self, style=wx.TE_LEFT|wx.TE_MULTILINE|wx.TE_BESTWRAP|wx.TE_READONLY|wx.TE_NO_VSCROLL) 
     46        self.ack = wx.TextCtrl(self, style=wx.TE_LEFT|wx.TE_MULTILINE|wx.TE_BESTWRAP|wx.TE_READONLY|wx.TE_NO_VSCROLL) 
    4747        self.ack.SetValue(config._acknowledgement_publications) 
    48         #self.ack.SetMinSize((-1, 55)) 
    49         self.citation = ExpandoTextCtrl(self, style=wx.TE_LEFT|wx.TE_MULTILINE|wx.TE_BESTWRAP|wx.TE_READONLY|wx.TE_NO_VSCROLL) 
    50         self.citation.SetValue(config._acknowledgement_citation) 
     48        self.ack.SetMinSize((-1, 55)) 
    5149        self.preamble = wx.StaticText(self, -1, config._acknowledgement_preamble) 
    5250        items = [config._acknowledgement_preamble_bullet1, 
    … …  
    5452                 config._acknowledgement_preamble_bullet3, 
    5553                 config._acknowledgement_preamble_bullet4] 
    56         self.list1 = wx.StaticText(self, -1, "(1) " + items[0]) 
    57         self.list2 = wx.StaticText(self, -1, "(2) " + items[1]) 
    58         self.list3 = wx.StaticText(self, -1, "(3) " + items[2]) 
    59         self.list4 = wx.StaticText(self, -1, "(4) " + items[3]) 
     54        self.list1 = wx.StaticText(self, -1, "\t(1) " + items[0]) 
     55        self.list2 = wx.StaticText(self, -1, "\t(2) " + items[1]) 
     56        self.list3 = wx.StaticText(self, -1, "\t(3) " + items[2]) 
     57        self.list4 = wx.StaticText(self, -1, "\t(4) " + items[3]) 
    6058        self.static_line = wx.StaticLine(self, 0) 
    6159        self.__set_properties() 
    … …  
    7169        self.SetTitle("Acknowledging SasView") 
    7270        #Increased size of box from (525, 225), SMK, 04/10/16 
    73         self.SetClientSize((600, 320)) 
     71        self.SetSize((600, 300)) 
    7472        # end wxGlade 
    7573 
    … …  
    8381        sizer_titles.Add(self.preamble, 0, wx.ALL|wx.EXPAND, 5) 
    8482        sizer_titles.Add(self.list1, 0, wx.ALL|wx.EXPAND, 5) 
     83        sizer_titles.Add(self.list2, 0, wx.ALL|wx.EXPAND, 5) 
     84        sizer_titles.Add(self.list3, 0, wx.ALL|wx.EXPAND, 5) 
     85        sizer_titles.Add(self.list4, 0, wx.ALL|wx.EXPAND, 5) 
     86        sizer_titles.Add(self.static_line, 0, wx.ALL|wx.EXPAND, 0) 
    8587        sizer_titles.Add(self.ack, 0, wx.ALL|wx.EXPAND, 5) 
    86         sizer_titles.Add(self.list2, 0, wx.ALL|wx.EXPAND, 5) 
    87         sizer_titles.Add(self.citation, 0, wx.ALL|wx.EXPAND, 5) 
    88         sizer_titles.Add(self.list3, 0, wx.ALL|wx.EXPAND, 5) 
    89         #sizer_titles.Add(self.static_line, 0, wx.ALL|wx.EXPAND, 0) 
    90         sizer_titles.Add(self.list4, 0, wx.ALL|wx.EXPAND, 5) 
    9188        sizer_main.Add(sizer_titles, -1, wx.ALL|wx.EXPAND, 5) 
    9289        self.SetAutoLayout(True) 
    … …  
    9491        self.Layout() 
    9592        self.Centre() 
    96         #self.SetClientSize(sizer_main.GetSize()) 
    9793        # end wxGlade 
    9894 

  • src/sas/sasgui/guiframe/config.py

    rf9d1f60 rd85c194  
    11""" 
    2     Application settings 
     2Application settings 
    33""" 
     4import os 
    45import time 
    5 import os 
    66from sas.sasgui.guiframe.gui_style import GUIFRAME 
    7 import sas.sasview 
    8 import logging 
    9  
    107# Version of the application 
    11 __appname__ = "SasView" 
    12 __version__ = sas.sasview.__version__ 
    13 __build__ = sas.sasview.__build__ 
     8__appname__ = "DummyView" 
     9__version__ = '0.0.0' 
     10__build__ = '1' 
    1411__download_page__ = 'https://github.com/SasView/sasview/releases' 
    1512__update_URL__ = 'http://www.sasview.org/latestversion.json' 
    1613 
     14 
    1715# Debug message flag 
    18 __EVT_DEBUG__ = False 
     16__EVT_DEBUG__ = True 
    1917 
    2018# Flag for automated testing 
    … …  
    3129_acknowledgement_preamble =\ 
    3230'''To ensure the long term support and development of this software please''' +\ 
    33 ''' remember to:''' 
     31''' remember to do the following.''' 
    3432_acknowledgement_preamble_bullet1 =\ 
    35 '''Acknowledge its use in your publications as :''' 
     33'''Acknowledge its use in your publications as suggested below''' 
    3634_acknowledgement_preamble_bullet2 =\ 
    37 '''Reference SasView as:''' 
     35'''Reference the following website: http://www.sasview.org''' 
    3836_acknowledgement_preamble_bullet3 =\ 
    3937'''Reference the model you used if appropriate (see documentation for refs)''' 
    … …  
    4139'''Send us your reference for our records: developers@sasview.org''' 
    4240_acknowledgement_publications = \ 
    43 '''This work benefited from the use of the SasView application, originally developed under NSF Award DMR-0520547. SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project Grant No 654000.''' 
    44 _acknowledgement_citation = \ 
    45 '''M. Doucet et al. SasView Version 4.1, Zenodo, 10.5281/zenodo.438138''' 
     41'''This work benefited from the use of the SasView application, originally 
     42developed under NSF award DMR-0520547. 
     43''' 
     44_acknowledgement =  \ 
     45'''This work originally developed as part of the DANSE project funded by the NSF 
     46under grant DMR-0520547, and currently maintained by NIST, UMD, ORNL, ISIS, ESS 
     47and ILL. 
    4648 
    47 _acknowledgement =  \ 
    48 '''This work was originally developed as part of the DANSE project funded by the US NSF under Award DMR-0520547,\n but is currently maintained by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft and the scattering community.\n\n SasView also contains code developed with funding from the EU Horizon 2020 programme under the SINE2020 project (Grant No 654000).\nA list of individual contributors can be found at: https://github.com/orgs/SasView/people 
    4949''' 
    50  
    5150_homepage = "http://www.sasview.org" 
    52 _download = __download_page__ 
     51_download = "http://sourceforge.net/projects/sasview/files/" 
    5352_authors = [] 
    5453_paper = "http://sourceforge.net/p/sasview/tickets/" 
    5554_license = "mailto:help@sasview.org" 
    56  
    57  
    58 icon_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "images")) 
    59 logging.info("icon path: %s" % icon_path) 
    60 media_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "media")) 
    61 test_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "test")) 
    62  
    63 _nist_logo = os.path.join(icon_path, "nist_logo.png") 
    64 _umd_logo = os.path.join(icon_path, "umd_logo.png") 
    65 _sns_logo = os.path.join(icon_path, "sns_logo.png") 
    66 _ornl_logo = os.path.join(icon_path, "ornl_logo.png") 
    67 _isis_logo = os.path.join(icon_path, "isis_logo.png") 
    68 _ess_logo = os.path.join(icon_path, "ess_logo.png") 
    69 _ill_logo = os.path.join(icon_path, "ill_logo.png") 
    70 _ansto_logo = os.path.join(icon_path, "ansto_logo.png") 
    71 _tudelft_logo = os.path.join(icon_path, "tudelft_logo.png") 
    72 _nsf_logo = os.path.join(icon_path, "nsf_logo.png") 
    73 _danse_logo = os.path.join(icon_path, "danse_logo.png") 
    74 _inst_logo = os.path.join(icon_path, "utlogo.gif") 
     55_nsf_logo = "images/nsf_logo.png" 
     56_danse_logo = "images/danse_logo.png" 
     57_inst_logo = "images/utlogo.gif" 
     58_nist_logo = "images/nist_logo.png" 
     59_umd_logo = "images/umd_logo.png" 
     60_sns_logo = "images/sns_logo.png" 
     61_isis_logo = "images/isis_logo.png" 
     62_ess_logo = "images/ess_logo.png" 
     63_ill_logo = "images/ill_logo.png" 
    7564_nist_url = "http://www.nist.gov/" 
    7665_umd_url = "http://www.umd.edu/" 
    7766_sns_url = "http://neutrons.ornl.gov/" 
    78 _ornl_url = "http://neutrons.ornl.gov/" 
    7967_nsf_url = "http://www.nsf.gov" 
     68_danse_url = "http://www.cacr.caltech.edu/projects/danse/release/index.html" 
     69_inst_url = "http://www.utk.edu" 
    8070_isis_url = "http://www.isis.stfc.ac.uk/" 
    8171_ess_url = "http://ess-scandinavia.eu/" 
    8272_ill_url = "http://www.ill.eu/" 
    83 _ansto_url = "http://www.ansto.gov.au/" 
    84 _tudelft_url = "http://www.tnw.tudelft.nl/en/cooperation/facilities/reactor-instituut-delft/" 
    85 _danse_url = "http://www.cacr.caltech.edu/projects/danse/release/index.html" 
    86 _inst_url = "http://www.utk.edu" 
    87 _corner_image = os.path.join(icon_path, "angles_flat.png") 
    88 _welcome_image = os.path.join(icon_path, "SVwelcome.png") 
    89 _copyright = "(c) 2009 - 2017, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft" 
    90 marketplace_url = "http://marketplace.sasview.org/" 
    91  
    92 #edit the list of file state your plugin can read 
    93 APPLICATION_WLIST = 'SasView files (*.svs)|*.svs' 
    94 APPLICATION_STATE_EXTENSION = '.svs' 
    95 GUIFRAME_WIDTH = 1150 
    96 GUIFRAME_HEIGHT = 840 
    97 PLUGIN_STATE_EXTENSIONS = ['.fitv', '.inv', '.prv', '.crf'] 
    98 PLUGINS_WLIST = ['Fitting files (*.fitv)|*.fitv', 
    99                  'Invariant files (*.inv)|*.inv', 
    100                  'P(r) files (*.prv)|*.prv', 
    101                  'Corfunc files (*.crf)|*.crf'] 
    102 PLOPANEL_WIDTH = 415 
    103 PLOPANEL_HEIGTH = 370 
     73_corner_image = "images/angles_flat.png" 
     74_welcome_image = "images/SVwelcome.png" 
     75_copyright = "(c) 2008, University of Tennessee" 
     76#edit the lists below of file state your plugin can read 
     77#for sasview this how you can edit these lists 
     78#PLUGIN_STATE_EXTENSIONS = ['.prv','.fitv', '.inv'] 
     79#APPLICATION_STATE_EXTENSION = '.svs' 
     80#PLUGINS_WLIST = ['P(r) files (*.prv)|*.prv', 
     81#                  'Fitting files (*.fitv)|*.fitv', 
     82#                  'Invariant files (*.inv)|*.inv'] 
     83#APPLICATION_WLIST = 'SasView files (*.svs)|*.svs' 
     84APPLICATION_WLIST = '' 
     85APPLICATION_STATE_EXTENSION = None 
     86PLUGINS_WLIST = [] 
     87PLUGIN_STATE_EXTENSIONS = [] 
     88SPLASH_SCREEN_PATH = "images/danse_logo.png" 
     89DEFAULT_STYLE = GUIFRAME.SINGLE_APPLICATION 
     90SPLASH_SCREEN_WIDTH = 500 
     91SPLASH_SCREEN_HEIGHT = 300 
     92WELCOME_PANEL_ON = False 
     93TUTORIAL_PATH = None 
     94SS_MAX_DISPLAY_TIME = 1500 
     95PLOPANEL_WIDTH = 350 
     96PLOPANEL_HEIGTH = 350 
     97GUIFRAME_WIDTH = 1000 
     98GUIFRAME_HEIGHT = 800 
     99CONTROL_WIDTH = -1 
     100CONTROL_HEIGHT = -1 
     101SetupIconFile_win = os.path.join("images", "ball.ico") 
     102SetupIconFile_mac = os.path.join("images", "ball.icns") 
     103DefaultGroupName = "DANSE" 
     104OutputBaseFilename = "setupGuiFrame" 
    104105DATAPANEL_WIDTH = 235 
    105106DATAPANEL_HEIGHT = 700 
    106 SPLASH_SCREEN_PATH = os.path.join(icon_path, "SVwelcome_mini.png") 
    107 TUTORIAL_PATH = os.path.join(media_path, "Tutorial.pdf") 
    108 DEFAULT_STYLE = GUIFRAME.MULTIPLE_APPLICATIONS|GUIFRAME.MANAGER_ON\ 
    109                     |GUIFRAME.CALCULATOR_ON|GUIFRAME.TOOLBAR_ON 
    110 SPLASH_SCREEN_WIDTH = 512 
    111 SPLASH_SCREEN_HEIGHT = 366 
    112 SS_MAX_DISPLAY_TIME = 2000 
    113 WELCOME_PANEL_ON = True 
    114 WELCOME_PANEL_SHOW = False 
    115 CLEANUP_PLOT = False 
    116 # OPEN and SAVE project menu 
    117 OPEN_SAVE_PROJECT_MENU = True 
    118 #VIEW MENU 
    119 VIEW_MENU = True 
    120 #EDIT MENU 
    121 EDIT_MENU = True 
    122  
    123 SetupIconFile_win = os.path.join(icon_path, "ball.ico") 
    124 SetupIconFile_mac = os.path.join(icon_path, "ball.icns") 
    125 DefaultGroupName = "." 
    126 OutputBaseFilename = "setupSasView" 
    127  
    128107FIXED_PANEL = True 
    129108DATALOADER_SHOW = True 
    … …  
    134113# set a default perspective 
    135114DEFAULT_PERSPECTIVE = 'None' 
    136  
    137 # Time out for updating sasview 
    138 UPDATE_TIMEOUT = 2 
    139  
    140 #OpenCL option 
    141 SAS_OPENCL = None 
     115# OPEN and SAVE project menu 
     116OPEN_SAVE_PROJECT_MENU = True 
     117CLEANUP_PLOT = False 
     118# OPEN and SAVE project menu 
     119OPEN_SAVE_PROJECT_MENU = False 
     120#VIEW MENU 
     121VIEW_MENU = False 
     122#EDIT MENU 
     123EDIT_MENU = False 
     124import wx.lib.newevent 
     125(StatusBarEvent, EVT_STATUS) = wx.lib.newevent.NewEvent() 
    142126 
    143127def printEVT(message): 
     128    """ 
     129    :TODO - need method documentation 
     130    """ 
    144131    if __EVT_DEBUG__: 
    145         """ 
    146         :TODO - Need method doc string 
    147         """ 
    148132        print "%g:  %s" % (time.clock(), message) 
    149  
     133     
    150134        if __EVT_DEBUG_2_FILE__: 
    151135            out = open(__EVT_DEBUG_FILENAME__, 'a') 
    152136            out.write("%10g:  %s\n" % (time.clock(), message)) 
    153137            out.close() 
     138             

  • src/sas/sasgui/perspectives/fitting/basepage.py

    rb301db9 r7a5aedd  
    120120        self.dxw = None 
    121121        # pinhole smear 
    122         self.dx_percent = None 
     122        self.dx_min = None 
     123        self.dx_max = None 
    123124        # smear attrbs 
    124125        self.enable_smearer = None 
    … …  
    848849        self.state.pinhole_smearer = \ 
    849850                                copy.deepcopy(self.pinhole_smearer.GetValue()) 
    850         self.state.dx_percent = copy.deepcopy(self.dx_percent) 
     851        self.state.dx_max = copy.deepcopy(self.dx_max) 
     852        self.state.dx_min = copy.deepcopy(self.dx_min) 
    851853        self.state.dxl = copy.deepcopy(self.dxl) 
    852854        self.state.dxw = copy.deepcopy(self.dxw) 
    … …  
    12451247        # we have two more options for smearing 
    12461248        if self.pinhole_smearer.GetValue(): 
    1247             self.dx_percent = state.dx_percent 
    1248             if self.dx_percent is not None: 
    1249                 if state.dx_old: 
    1250                     self.dx_percent = 100 * (self.dx_percent / self.data.x[0]) 
    1251                 self.smear_pinhole_percent.SetValue("%.2f" % self.dx_percent) 
     1249            self.dx_min = state.dx_min 
     1250            self.dx_max = state.dx_max 
     1251            if self.dx_min is not None: 
     1252                self.smear_pinhole_min.SetValue(str(self.dx_min)) 
     1253            if self.dx_max is not None: 
     1254                self.smear_pinhole_max.SetValue(str(self.dx_max)) 
    12521255            self.onPinholeSmear(event=None) 
    12531256        elif self.slit_smearer.GetValue(): 

  • src/sas/sasgui/perspectives/fitting/fitpage.py

    rd85f1d8a r2d568f6  
    2929_BOX_WIDTH = 76 
    3030_DATA_BOX_WIDTH = 300 
     31SMEAR_SIZE_L = 0.00 
    3132SMEAR_SIZE_H = 0.00 
    3233CUSTOM_MODEL = 'Plugin Models' 
    … …  
    209210              "Please enter only the value of interest to customize smearing..." 
    210211        smear_message_new_psmear = \ 
    211               "Please enter a fixed percentage to be applied to all Q values..." 
     212              "Please enter both; the dQ will be generated by interpolation..." 
    212213        smear_message_2d_x_title = "<dQp>[1/A]:" 
    213214        smear_message_2d_y_title = "<dQs>[1/A]:" 
    214         smear_message_pinhole_percent_title = "dQ[%]:" 
     215        smear_message_pinhole_min_title = "dQ_low[1/A]:" 
     216        smear_message_pinhole_max_title = "dQ_high[1/A]:" 
    215217        smear_message_slit_height_title = "Slit height[1/A]:" 
    216218        smear_message_slit_width_title = "Slit width[1/A]:" 
    … …  
    305307         
    306308        # textcntrl for custom resolution 
    307         self.smear_pinhole_percent = ModelTextCtrl(self, wx.ID_ANY, 
    308                                                    size=(_BOX_WIDTH - 25, 20), 
    309                                                    style=wx.TE_PROCESS_ENTER, 
    310                                                    text_enter_callback= 
    311                                                    self.onPinholeSmear) 
     309        self.smear_pinhole_max = ModelTextCtrl(self, wx.ID_ANY, 
     310                            size=(_BOX_WIDTH - 25, 20), 
     311                            style=wx.TE_PROCESS_ENTER, 
     312                            text_enter_callback=self.onPinholeSmear) 
     313        self.smear_pinhole_min = ModelTextCtrl(self, wx.ID_ANY, 
     314                            size=(_BOX_WIDTH - 25, 20), 
     315                            style=wx.TE_PROCESS_ENTER, 
     316                            text_enter_callback=self.onPinholeSmear) 
    312317        self.smear_slit_height = ModelTextCtrl(self, wx.ID_ANY, 
    313318                            size=(_BOX_WIDTH - 25, 20), 
    … …  
    328333 
    329334        # set default values for smear 
    330         self.smear_pinhole_percent.SetValue(str(self.dx_percent)) 
     335        self.smear_pinhole_max.SetValue(str(self.dx_max)) 
     336        self.smear_pinhole_min.SetValue(str(self.dx_min)) 
    331337        self.smear_slit_height.SetValue(str(self.dxl)) 
    332338        self.smear_slit_width.SetValue(str(self.dxw)) 
    … …  
    420426        self.smear_description_2d_y.SetToolTipString( 
    421427                                    " dQs(perpendicular) in q_phi direction.") 
    422         self.smear_description_pin_percent = wx.StaticText(self, wx.ID_ANY, 
    423                                             smear_message_pinhole_percent_title, 
    424                                             style=wx.ALIGN_LEFT) 
     428        self.smear_description_pin_min = wx.StaticText(self, wx.ID_ANY, 
     429                        smear_message_pinhole_min_title, style=wx.ALIGN_LEFT) 
     430        self.smear_description_pin_max = wx.StaticText(self, wx.ID_ANY, 
     431                        smear_message_pinhole_max_title, style=wx.ALIGN_LEFT) 
    425432        self.smear_description_slit_height = wx.StaticText(self, wx.ID_ANY, 
    426433                        smear_message_slit_height_title, style=wx.ALIGN_LEFT) 
    … …  
    446453        self.sizer_new_smear.Add((15, -1)) 
    447454        self.sizer_new_smear.Add(self.smear_description_2d_x, 0, wx.CENTER, 10) 
     455        self.sizer_new_smear.Add(self.smear_description_pin_min, 
     456                                 0, wx.CENTER, 10) 
    448457        self.sizer_new_smear.Add(self.smear_description_slit_height, 
    449458                                 0, wx.CENTER, 10) 
    450459 
     460        self.sizer_new_smear.Add(self.smear_pinhole_min, 0, wx.CENTER, 10) 
    451461        self.sizer_new_smear.Add(self.smear_slit_height, 0, wx.CENTER, 10) 
    452462        self.sizer_new_smear.Add(self.smear_data_left, 0, wx.CENTER, 10) 
    … …  
    454464        self.sizer_new_smear.Add(self.smear_description_2d_y, 
    455465                                 0, wx.CENTER, 10) 
    456         self.sizer_new_smear.Add(self.smear_description_pin_percent, 
     466        self.sizer_new_smear.Add(self.smear_description_pin_max, 
    457467                                 0, wx.CENTER, 10) 
    458468        self.sizer_new_smear.Add(self.smear_description_slit_width, 
    459469                                 0, wx.CENTER, 10) 
    460470 
    461         self.sizer_new_smear.Add(self.smear_pinhole_percent, 0, wx.CENTER, 10) 
     471        self.sizer_new_smear.Add(self.smear_pinhole_max, 0, wx.CENTER, 10) 
    462472        self.sizer_new_smear.Add(self.smear_slit_width, 0, wx.CENTER, 10) 
    463473        self.sizer_new_smear.Add(self.smear_data_right, 0, wx.CENTER, 10) 
    … …  
    15711581        if self.dxw is None: 
    15721582            self.dxw = "" 
    1573         if self.dx_percent is None: 
    1574             self.dx_percent = SMEAR_SIZE_H 
     1583        if self.dx_min is None: 
     1584            self.dx_min = SMEAR_SIZE_L 
     1585        if self.dx_max is None: 
     1586            self.dx_max = SMEAR_SIZE_H 
    15751587 
    15761588    def _get_smear_info(self): 
    … …  
    16341646            self.smear_description_2d_y.Show(True) 
    16351647            if self.pinhole_smearer.GetValue(): 
    1636                 self.smear_pinhole_percent.Show(True) 
     1648                self.smear_pinhole_min.Show(True) 
     1649                self.smear_pinhole_max.Show(True) 
    16371650        # smear from data 
    16381651        elif self.enable_smearer.GetValue(): 
    … …  
    16451658                    self.smear_description_slit_width.Show(True) 
    16461659                elif self.smear_type == 'Pinhole': 
    1647                     self.smear_description_pin_percent.Show(True) 
     1660                    self.smear_description_pin_min.Show(True) 
     1661                    self.smear_description_pin_max.Show(True) 
    16481662                self.smear_description_smear_type.Show(True) 
    16491663                self.smear_description_type.Show(True) 
    … …  
    16541668            if self.smear_type == 'Pinhole': 
    16551669                self.smear_message_new_p.Show(True) 
    1656                 self.smear_description_pin_percent.Show(True) 
    1657  
    1658             self.smear_pinhole_percent.Show(True) 
     1670                self.smear_description_pin_min.Show(True) 
     1671                self.smear_description_pin_max.Show(True) 
     1672 
     1673            self.smear_pinhole_min.Show(True) 
     1674            self.smear_pinhole_max.Show(True) 
    16591675        # custom slit smear 
    16601676        elif self.slit_smearer.GetValue(): 
    … …  
    16811697        self.smear_data_left.Hide() 
    16821698        self.smear_data_right.Hide() 
    1683         self.smear_description_pin_percent.Hide() 
    1684         self.smear_pinhole_percent.Hide() 
     1699        self.smear_description_pin_min.Hide() 
     1700        self.smear_pinhole_min.Hide() 
     1701        self.smear_description_pin_max.Hide() 
     1702        self.smear_pinhole_max.Hide() 
    16851703        self.smear_description_slit_height.Hide() 
    16861704        self.smear_slit_height.Hide() 
    … …  
    22312249            # event case of radio button 
    22322250            if tcrtl.GetValue(): 
    2233                 self.dx_percent = 0.0 
     2251                self.dx_min = 0.0 
     2252                self.dx_max = 0.0 
    22342253                is_new_pinhole = True 
    22352254            else: 
    … …  
    22682287        """ 
    22692288        # get the values 
    2270         pin_percent = self.smear_pinhole_percent.GetValue() 
     2289        pin_min = self.smear_pinhole_min.GetValue() 
     2290        pin_max = self.smear_pinhole_max.GetValue() 
     2291 
     2292        # Check changes in slit width 
     2293        try: 
     2294            dx_min = float(pin_min) 
     2295        except: 
     2296            return True 
     2297        if self.dx_min != dx_min: 
     2298            return True 
    22712299 
    22722300        # Check changes in slit heigth 
    22732301        try: 
    2274             dx_percent = float(pin_percent) 
     2302            dx_max = float(pin_max) 
    22752303        except: 
    22762304            return True 
    2277         if self.dx_percent != dx_percent: 
     2305        if self.dx_max != dx_max: 
    22782306            return True 
    22792307        return False 
    … …  
    23012329        msg = None 
    23022330 
    2303         get_pin_percent = self.smear_pinhole_percent 
    2304  
    2305         if not check_float(get_pin_percent): 
    2306             get_pin_percent.SetBackgroundColour("pink") 
     2331        get_pin_min = self.smear_pinhole_min 
     2332        get_pin_max = self.smear_pinhole_max 
     2333 
     2334        if not check_float(get_pin_min): 
     2335            get_pin_min.SetBackgroundColour("pink") 
     2336            msg = "Model Error:wrong value entered!!!" 
     2337        elif not check_float(get_pin_max): 
     2338            get_pin_max.SetBackgroundColour("pink") 
    23072339            msg = "Model Error:wrong value entered!!!" 
    23082340        else: 
    23092341            if len_data < 2: 
    23102342                len_data = 2 
    2311             self.dx_percent = float(get_pin_percent.GetValue()) 
    2312             if self.dx_percent < 0: 
    2313                 get_pin_percent.SetBackgroundColour("pink") 
     2343            self.dx_min = float(get_pin_min.GetValue()) 
     2344            self.dx_max = float(get_pin_max.GetValue()) 
     2345            if self.dx_min < 0: 
     2346                get_pin_min.SetBackgroundColour("pink") 
    23142347                msg = "Model Error:This value can not be negative!!!" 
    2315             elif self.dx_percent is not None: 
    2316                 percent = self.dx_percent/100 
     2348            elif self.dx_max < 0: 
     2349                get_pin_max.SetBackgroundColour("pink") 
     2350                msg = "Model Error:This value can not be negative!!!" 
     2351            elif self.dx_min is not None and self.dx_max is not None: 
    23172352                if self._is_2D(): 
    2318                     data.dqx_data[data.dqx_data == 0] = percent * data.qx_data 
    2319                     data.dqy_data[data.dqy_data == 0] = percent * data.qy_data 
     2353                    data.dqx_data[data.dqx_data == 0] = self.dx_min 
     2354                    data.dqy_data[data.dqy_data == 0] = self.dx_max 
     2355                elif self.dx_min == self.dx_max: 
     2356                    data.dx[data.dx == 0] = self.dx_min 
    23202357                else: 
    2321                     data.dx = percent * data.x 
     2358                    step = (self.dx_max - self.dx_min) / (len_data - 1) 
     2359                    data.dx = numpy.arange(self.dx_min, 
     2360                                           self.dx_max + step / 1.1, 
     2361                                           step) 
     2362            elif self.dx_min is not None: 
     2363                if self._is_2D(): 
     2364                    data.dqx_data[data.dqx_data == 0] = self.dx_min 
     2365                else: 
     2366                    data.dx[data.dx == 0] = self.dx_min 
     2367            elif self.dx_max is not None: 
     2368                if self._is_2D(): 
     2369                    data.dqy_data[data.dqy_data == 0] = self.dx_max 
     2370                else: 
     2371                    data.dx[data.dx == 0] = self.dx_max 
    23222372            self.current_smearer = smear_selection(data, self.model) 
    23232373            # 2D need to set accuracy 
    … …  
    23292379            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    23302380        else: 
    2331             get_pin_percent.SetBackgroundColour("white") 
     2381            get_pin_min.SetBackgroundColour("white") 
     2382            get_pin_max.SetBackgroundColour("white") 
    23322383        # set smearing value whether or not the data contain the smearing info 
    23332384 

  • src/sas/sasgui/perspectives/fitting/fitting.py

    r4c5098c rddbac66  
    17551755                                          data_id="Data  " + data.name + " unsmeared", 
    17561756                                          dy=unsmeared_error) 
    1757             # Comment this out until we can get P*S models with correctly populated parameters 
    1758             #if sq_model is not None and pq_model is not None: 
    1759             #    self.create_theory_1D(x, sq_model, page_id, model, data, state, 
    1760             #                          data_description=model.name + " S(q)", 
    1761             #                          data_id=str(page_id) + " " + data.name + " S(q)") 
    1762             #    self.create_theory_1D(x, pq_model, page_id, model, data, state, 
    1763             #                          data_description=model.name + " P(q)", 
    1764             #                          data_id=str(page_id) + " " + data.name + " P(q)") 
     1757                 
     1758            if sq_model is not None and pq_model is not None: 
     1759                self.create_theory_1D(x, sq_model, page_id, model, data, state, 
     1760                                      data_description=model.name + " S(q)", 
     1761                                      data_id=str(page_id) + " " + data.name + " S(q)") 
     1762                self.create_theory_1D(x, pq_model, page_id, model, data, state, 
     1763                                      data_description=model.name + " P(q)", 
     1764                                      data_id=str(page_id) + " " + data.name + " P(q)") 
     1765 
    17651766 
    17661767            current_pg = self.fit_panel.get_page_by_id(page_id) 

  • src/sas/sasgui/perspectives/fitting/media/plugin.rst

    r984f3fc r5295cf5  
    364364  - the limits will show up as the default limits for the fit making it easy, 
    365365    for example, to force the radius to always be greater than zero. 
    366  
    367   - these are hard limits defining the valid range of parameter values; 
    368     polydisperity distributions will be truncated at the limits. 
    369366 
    370367- **"type"** can be one of: "", "sld", "volume", or "orientation". 

  • src/sas/sasgui/perspectives/fitting/pagestate.py

    r27109e5 r71601312  
    7474                            ["dq_l", "dq_l", "float"], 
    7575                            ["dq_r", "dq_r", "float"], 
    76                             ["dx_percent", "dx_percent", "float"], 
     76                            ["dx_max", "dx_max", "float"], 
     77                            ["dx_min", "dx_min", "float"], 
    7778                            ["dxl", "dxl", "float"], 
    7879                            ["dxw", "dxw", "float"]] 
    … …  
    214215        self.dq_l = None 
    215216        self.dq_r = None 
    216         self.dx_percent = None 
    217         self.dx_old = False 
     217        self.dx_max = None 
     218        self.dx_min = None 
    218219        self.dxl = None 
    219220        self.dxw = None 
    … …  
    342343        obj.dq_l = copy.deepcopy(self.dq_l) 
    343344        obj.dq_r = copy.deepcopy(self.dq_r) 
    344         obj.dx_percent = copy.deepcopy(self.dx_percent) 
    345         obj.dx_old = copy.deepcopy(self.dx_old) 
     345        obj.dx_max = copy.deepcopy(self.dx_max) 
     346        obj.dx_min = copy.deepcopy(self.dx_min) 
    346347        obj.dxl = copy.deepcopy(self.dxl) 
    347348        obj.dxw = copy.deepcopy(self.dxw) 
    … …  
    561562        rep += "dq_l  : %s\n" % self.dq_l 
    562563        rep += "dq_r  : %s\n" % self.dq_r 
    563         rep += "dx_percent  : %s\n" % str(self.dx_percent) 
     564        rep += "dx_max  : %s\n" % str(self.dx_max) 
     565        rep += "dx_min : %s\n" % str(self.dx_min) 
    564566        rep += "dxl  : %s\n" % str(self.dxl) 
    565567        rep += "dxw : %s\n" % str(self.dxw) 
    … …  
    819821 
    820822        attr = newdoc.createAttribute("version") 
    821         from sas import sasview 
     823        import sasview 
    822824        attr.nodeValue = sasview.__version__ 
    823825        # attr.nodeValue = '1.0' 
    … …  
    10461048                    setattr(self, item[0], parse_entry_helper(node, item)) 
    10471049 
    1048                 dx_old_node = get_content('ns:%s' % 'dx_min', entry) 
    10491050                for item in LIST_OF_STATE_ATTRIBUTES: 
    1050                     if item[0] == "dx_percent" and dx_old_node is not None: 
    1051                         dxmin = ["dx_min", "dx_min", "float"] 
    1052                         setattr(self, item[0], parse_entry_helper(dx_old_node, 
    1053                                                                   dxmin)) 
    1054                         self.dx_old = True 
    1055                     else: 
    1056                         node = get_content('ns:%s' % item[0], entry) 
    1057                         setattr(self, item[0], parse_entry_helper(node, item)) 
     1051                    node = get_content('ns:%s' % item[0], entry) 
     1052                    setattr(self, item[0], parse_entry_helper(node, item)) 
    10581053 
    10591054                for item in LIST_OF_STATE_PARAMETERS: 
Note: See TracChangeset for help on using the changeset viewer.