Changes in / [5156918:1a8e13f0] in sasview


Ignore:
Files:
2 added
2 deleted
30 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 r18e7309  
    206206) 
    207207 
     208 
    208209# sas.sascalc.pr 
    209210srcdir  = os.path.join("src", "sas", "sascalc", "pr", "c_extensions") 
    … …  
    228229                              ) ) 
    229230 
    230 #sas.sascalc.corfunc 
    231 package_dir["sas.sascalc.corfunc"] = os.path.join("src", "sas", "sascalc", "corfunc") 
    232 packages.extend(["sas.sascalc.corfunc"]) 
    233  
    234231# sas.sascalc.fit 
    235232package_dir["sas.sascalc.fit"] = os.path.join("src", "sas", "sascalc", "fit") 
    … …  
    240237package_dir["sas.sasgui.perspectives.pr"] = os.path.join("src", "sas", "sasgui", "perspectives", "pr") 
    241238packages.extend(["sas.sasgui.perspectives","sas.sasgui.perspectives.pr"]) 
    242 package_data["sas.sasgui.perspectives.pr"] = ['media/*'] 
     239package_data["sas.sasgui.perspectives.pr"] = ['images/*'] 
    243240 
    244241package_dir["sas.sasgui.perspectives.invariant"] = os.path.join("src", "sas", "sasgui", "perspectives", "invariant") 
    … …  
    253250packages.extend(["sas.sasgui.perspectives", "sas.sasgui.perspectives.calculator"]) 
    254251package_data['sas.sasgui.perspectives.calculator'] = ['images/*', 'media/*'] 
    255  
    256 package_dir["sas.sasgui.perspectives.corfunc"] = os.path.join("src", "sas", "sasgui", "perspectives", "corfunc") 
    257 packages.extend(["sas.sasgui.perspectives.corfunc"]) 
    258 package_data['sas.sasgui.perspectives.corfunc'] = ['media/*'] 
    259  
    260 package_dir["sas.sasgui.perspectives.file_converter"] = os.path.join("src", "sas", "sasgui", "perspectives", "file_converter") 
    261 packages.extend(["sas.sasgui.perspectives.file_converter"]) 
    262 package_data['sas.sasgui.perspectives.file_converter'] = ['media/*'] 
    263252 
    264253# Data util 
    … …  
    315304                               'test/1d_data/*', 
    316305                               'test/2d_data/*', 
    317                                'test/convertible_files/*', 
    318                                'test/coordinate_data/*', 
    319                                'test/image_data/*', 
    320                                'test/media/*', 
    321                                'test/other_files/*', 
    322306                               'test/save_states/*', 
    323                                'test/sesans_data/*' 
    324                                ] 
     307                               'test/upcoming_formats/*', 
     308                                 'default_categories.json'] 
    325309packages.append("sas.sasview") 
    326310 

  • 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/data_util/qsmearing.py

    rc1c9929 rd3911e3  
    1414import sys 
    1515 
    16 import numpy as np  # type: ignore 
    17 from numpy import pi, exp # type:ignore 
    18  
    1916from sasmodels.resolution import Slit1D, Pinhole1D 
    20 from sasmodels.sesans import SesansTransform 
    2117from sasmodels.resolution2d import Pinhole2D 
    22 from .nxsunit import Converter 
    2318 
    2419def smear_selection(data, model = None): 
    … …  
    4136    # Sanity check. If we are not dealing with a SAS Data1D 
    4237    # object, just return None 
    43     # This checks for 2D data (does not throw exception because fail is common) 
    4438    if  data.__class__.__name__ not in ['Data1D', 'Theory1D']: 
    4539        if data == None: 
    … …  
    4741        elif data.dqx_data == None or data.dqy_data == None: 
    4842            return None 
    49         return PySmear2D(data) 
    50     # This checks for 1D data with smearing info in the data itself (again, fail is likely; no exceptions) 
     43        return PySmear2D(data, model) 
     44 
    5145    if  not hasattr(data, "dx") and not hasattr(data, "dxl")\ 
    5246         and not hasattr(data, "dxw"): 
    … …  
    5448 
    5549    # Look for resolution smearing data 
    56     # This is the code that checks for SESANS data; it looks for the file loader 
    57     # TODO: change other sanity checks to check for file loader instead of data structure? 
    58     _found_sesans = False 
    59     #if data.dx is not None and data.meta_data['loader']=='SESANS': 
    60     if data.dx is not None and data.isSesans: 
    61         #if data.dx[0] > 0.0: 
    62         if numpy.size(data.dx[data.dx <= 0]) == 0: 
    63             _found_sesans = True 
    64         # if data.dx[0] <= 0.0: 
    65         if numpy.size(data.dx[data.dx <= 0]) > 0: 
    66             raise ValueError('one or more of your dx values are negative, please check the data file!') 
    67  
    68     if _found_sesans == True: 
    69         #Pre-compute the Hankel matrix (H) 
    70         qmax, qunits = data.sample.zacceptance 
    71         SElength = Converter(data._xunit)(data.x, "A") 
    72         zaccept = Converter(qunits)(qmax, "1/A"), 
    73         Rmax = 10000000 
    74         hankel = SesansTransform(data.x, SElength, zaccept, Rmax) 
    75         # Then return the actual transform, as if it were a smearing function 
    76         return PySmear(hankel, model, offset=0) 
    77  
    7850    _found_resolution = False 
    7951    if data.dx is not None and len(data.dx) == len(data.x): 
    … …  
    11789    Wrapper for pure python sasmodels resolution functions. 
    11890    """ 
    119     def __init__(self, resolution, model, offset=None): 
     91    def __init__(self, resolution, model): 
    12092        self.model = model 
    12193        self.resolution = resolution 
    122         if offset is None: 
    123             offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    124         self.offset = offset 
     94        self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    12595 
    12696    def apply(self, iq_in, first_bin=0, last_bin=None): 

  • src/sas/sascalc/dataloader/data_info.py

    r2ffe241 r345e7e4  
    2525import numpy 
    2626import math 
     27 
     28class plottable_sesans1D(object): 
     29    """ 
     30    SESANS is a place holder for 1D SESANS plottables. 
     31 
     32    #TODO: This was directly copied from the plottables_1D. Modified Somewhat. 
     33    #Class has been updated. 
     34    """ 
     35    # The presence of these should be mutually 
     36    # exclusive with the presence of Qdev (dx) 
     37    x = None 
     38    y = None 
     39    lam = None 
     40    dx = None 
     41    dy = None 
     42    dlam = None 
     43    ## Slit smearing length 
     44    dxl = None 
     45    ## Slit smearing width 
     46    dxw = None 
     47 
     48    # Units 
     49    _xaxis = '' 
     50    _xunit = '' 
     51    _yaxis = '' 
     52    _yunit = '' 
     53 
     54    def __init__(self, x, y, lam, dx=None, dy=None, dlam=None): 
     55#        print "SESANS plottable working" 
     56        self.x = numpy.asarray(x) 
     57        self.y = numpy.asarray(y) 
     58        self.lam = numpy.asarray(lam) 
     59        if dx is not None: 
     60            self.dx = numpy.asarray(dx) 
     61        if dy is not None: 
     62            self.dy = numpy.asarray(dy) 
     63        if dlam is not None: 
     64            self.dlam = numpy.asarray(dlam) 
     65 
     66    def xaxis(self, label, unit): 
     67        """ 
     68        set the x axis label and unit 
     69        """ 
     70        self._xaxis = label 
     71        self._xunit = unit 
     72 
     73    def yaxis(self, label, unit): 
     74        """ 
     75        set the y axis label and unit 
     76        """ 
     77        self._yaxis = label 
     78        self._yunit = unit 
     79 
    2780 
    2881class plottable_1D(object): 
    … …  
    4093    ## Slit smearing width 
    4194    dxw = None 
    42     ## SESANS specific params (wavelengths for spin echo length calculation) 
    43     lam = None 
    44     dlam = None 
    4595 
    4696    # Units 
    … …  
    50100    _yunit = '' 
    51101 
    52     def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None, lam=None, dlam=None): 
     102    def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None): 
    53103        self.x = numpy.asarray(x) 
    54104        self.y = numpy.asarray(y) 
    … …  
    61111        if dxw is not None: 
    62112            self.dxw = numpy.asarray(dxw) 
    63         if lam is not None: 
    64             self.lam = numpy.asarray(lam) 
    65         if dlam is not None: 
    66             self.dlam = numpy.asarray(dlam) 
    67113 
    68114    def xaxis(self, label, unit): 
    … …  
    352398    ## Details 
    353399    details = None 
    354     ## SESANS zacceptance 
    355     zacceptance = None 
    356400 
    357401    def __init__(self): 
    … …  
    491535    ## Loading errors 
    492536    errors = None 
    493     ## SESANS data check 
    494     isSesans = None 
    495  
    496537 
    497538    def __init__(self): 
    … …  
    526567        ## Loading errors 
    527568        self.errors = [] 
    528         ## SESANS data check 
    529         self.isSesans = False 
    530569 
    531570    def append_empty_process(self): 
    … …  
    547586        _str += "Title:           %s\n" % self.title 
    548587        _str += "Run:             %s\n" % str(self.run) 
    549         _str += "SESANS:          %s\n" % str(self.isSesans) 
    550588        _str += "Instrument:      %s\n" % str(self.instrument) 
    551589        _str += "%s\n" % str(self.sample) 
    … …  
    698736        return self._perform_union(other) 
    699737 
    700 class Data1D(plottable_1D, DataInfo): 
    701     """ 
    702     1D data class 
    703     """ 
    704     def __init__(self, x=None, y=None, dx=None, dy=None, lam=None, dlam=None, isSesans=None): 
     738class SESANSData1D(plottable_sesans1D, DataInfo): 
     739    """ 
     740    SESANS 1D data class 
     741    """ 
     742    x_unit = 'nm' 
     743    y_unit = 'pol' 
     744 
     745    def __init__(self, x=None, y=None, lam=None, dx=None, dy=None, dlam=None): 
    705746        DataInfo.__init__(self) 
    706         plottable_1D.__init__(self, x, y, dx, dy,None, None, lam, dlam) 
    707         self.isSesans = isSesans 
    708         try: 
    709             if self.isSesans: # the data is SESANS 
    710                 self.x_unit = 'A' 
    711                 self.y_unit = 'pol' 
    712             elif not self.isSesans: # the data is SANS 
    713                 self.x_unit = '1/A' 
    714                 self.y_unit = '1/cm' 
    715         except: # the data is not recognized/supported, and the user is notified 
    716             raise(TypeError, 'data not recognized, check documentation for supported 1D data formats') 
     747        plottable_sesans1D.__init__(self, x, y, lam, dx, dy, dlam) 
    717748 
    718749    def __str__(self): 
    … …  
    728759        return _str 
    729760 
     761    def clone_without_data(self, length=0, clone=None): 
     762        """ 
     763        Clone the current object, without copying the data (which 
     764        will be filled out by a subsequent operation). 
     765        The data arrays will be initialized to zero. 
     766 
     767        :param length: length of the data array to be initialized 
     768        :param clone: if provided, the data will be copied to clone 
     769        """ 
     770        from copy import deepcopy 
     771        if clone is None or not issubclass(clone.__class__, Data1D): 
     772            x = numpy.zeros(length) 
     773            dx = numpy.zeros(length) 
     774            y = numpy.zeros(length) 
     775            dy = numpy.zeros(length) 
     776            clone = Data1D(x, y, dx=dx, dy=dy) 
     777 
     778        clone.title = self.title 
     779        clone.run = self.run 
     780        clone.filename = self.filename 
     781        clone.instrument = self.instrument 
     782        clone.notes = deepcopy(self.notes) 
     783        clone.process = deepcopy(self.process) 
     784        clone.detector = deepcopy(self.detector) 
     785        clone.sample = deepcopy(self.sample) 
     786        clone.source = deepcopy(self.source) 
     787        clone.collimation = deepcopy(self.collimation) 
     788        clone.trans_spectrum = deepcopy(self.trans_spectrum) 
     789        clone.meta_data = deepcopy(self.meta_data) 
     790        clone.errors = deepcopy(self.errors) 
     791 
     792        return clone 
     793 
     794class Data1D(plottable_1D, DataInfo): 
     795    """ 
     796    1D data class 
     797    """ 
     798    x_unit = '1/A' 
     799    y_unit = '1/cm' 
     800 
     801    def __init__(self, x, y, dx=None, dy=None): 
     802        DataInfo.__init__(self) 
     803        plottable_1D.__init__(self, x, y, dx, dy) 
     804 
     805    def __str__(self): 
     806        """ 
     807        Nice printout 
     808        """ 
     809        _str = "%s\n" % DataInfo.__str__(self) 
     810        _str += "Data:\n" 
     811        _str += "   Type:         %s\n" % self.__class__.__name__ 
     812        _str += "   X-axis:       %s\t[%s]\n" % (self._xaxis, self._xunit) 
     813        _str += "   Y-axis:       %s\t[%s]\n" % (self._yaxis, self._yunit) 
     814        _str += "   Length:       %g\n" % len(self.x) 
     815        return _str 
     816 
    730817    def is_slit_smeared(self): 
    731818        """ 
    … …  
    756843            y = numpy.zeros(length) 
    757844            dy = numpy.zeros(length) 
    758             lam = numpy.zeros(length) 
    759             dlam = numpy.zeros(length) 
    760             clone = Data1D(x, y, lam=lam, dx=dx, dy=dy, dlam=dlam) 
     845            clone = Data1D(x, y, dx=dx, dy=dy) 
    761846 
    762847        clone.title = self.title 
    … …  
    9331018    ## Vector of Q-values at the center of each bin in y 
    9341019    y_bins = None 
    935     ## No 2D SESANS data as of yet. Always set it to False 
    936     isSesans = False 
    9371020 
    9381021    def __init__(self, data=None, err_data=None, qx_data=None, 
    9391022                 qy_data=None, q_data=None, mask=None, 
    9401023                 dqx_data=None, dqy_data=None): 
     1024        self.y_bins = [] 
     1025        self.x_bins = [] 
    9411026        DataInfo.__init__(self) 
    9421027        plottable_2D.__init__(self, data, err_data, qx_data, 
    9431028                              qy_data, q_data, mask, dqx_data, dqy_data) 
    944         self.y_bins = [] 
    945         self.x_bins = [] 
    946  
    9471029        if len(self.detector) > 0: 
    9481030            raise RuntimeError, "Data2D: Detector bank already filled at init" 
    … …  
    11831265    final_dataset.xmin = data.xmin 
    11841266    final_dataset.ymin = data.ymin 
    1185     final_dataset.isSesans = datainfo.isSesans 
    11861267    final_dataset.title = datainfo.title 
    11871268    final_dataset.run = datainfo.run 

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

    rad4632c r250fec92  
    133133               "variable" : None, 
    134134               "children" : {"Idata" : SASDATA_IDATA, 
    135                              "Sesans": {"storeas": "content"}, 
    136                              "zacceptance": {"storeas": "float"}, 
    137135                             "<any>" : ANY 
    138136                            } 

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

    r8434365 rbcabf4e  
    261261                # I and Q - 1D data 
    262262                elif tagname == 'I' and isinstance(self.current_dataset, plottable_1D): 
    263                     unit_list = unit.split("|") 
    264                     if len(unit_list) > 1: 
    265                         self.current_dataset.yaxis(unit_list[0].strip(), 
    266                                                    unit_list[1].strip()) 
    267                     else: 
    268                         self.current_dataset.yaxis("Intensity", unit) 
     263                    self.current_dataset.yaxis("Intensity", unit) 
    269264                    self.current_dataset.y = np.append(self.current_dataset.y, data_point) 
    270265                elif tagname == 'Idev' and isinstance(self.current_dataset, plottable_1D): 
    271266                    self.current_dataset.dy = np.append(self.current_dataset.dy, data_point) 
    272267                elif tagname == 'Q': 
    273                     unit_list = unit.split("|") 
    274                     if len(unit_list) > 1: 
    275                         self.current_dataset.xaxis(unit_list[0].strip(), 
    276                                                    unit_list[1].strip()) 
    277                     else: 
    278                         self.current_dataset.xaxis("Q", unit) 
     268                    self.current_dataset.xaxis("Q", unit) 
    279269                    self.current_dataset.x = np.append(self.current_dataset.x, data_point) 
    280270                elif tagname == 'Qdev': 
    … …  
    288278                elif tagname == 'Shadowfactor': 
    289279                    pass 
    290                 elif tagname == 'Sesans': 
    291                     self.current_datainfo.isSesans = bool(data_point) 
    292                 elif tagname == 'zacceptance': 
    293                     self.current_datainfo.sample.zacceptance = (data_point, unit) 
    294280 
    295281                # I and Qx, Qy - 2D data 
    … …  
    930916            self._write_data(datainfo, entry_node) 
    931917        # Transmission Spectrum Info 
    932         # TODO: fix the writer to linearize all data, including T_spectrum 
    933         # self._write_trans_spectrum(datainfo, entry_node) 
     918        self._write_trans_spectrum(datainfo, entry_node) 
    934919        # Sample info 
    935920        self._write_sample_info(datainfo, entry_node) 
    … …  
    10351020            node.append(point) 
    10361021            self.write_node(point, "Q", datainfo.x[i], 
    1037                             {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
     1022                            {'unit': datainfo.x_unit}) 
    10381023            if len(datainfo.y) >= i: 
    10391024                self.write_node(point, "I", datainfo.y[i], 
    1040                                 {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
     1025                                {'unit': datainfo.y_unit}) 
    10411026            if datainfo.dy is not None and len(datainfo.dy) > i: 
    10421027                self.write_node(point, "Idev", datainfo.dy[i], 
    1043                                 {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
     1028                                {'unit': datainfo.y_unit}) 
    10441029            if datainfo.dx is not None and len(datainfo.dx) > i: 
    10451030                self.write_node(point, "Qdev", datainfo.dx[i], 
    1046                                 {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
     1031                                {'unit': datainfo.x_unit}) 
    10471032            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    10481033                self.write_node(point, "dQw", datainfo.dxw[i], 
    1049                                 {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
     1034                                {'unit': datainfo.x_unit}) 
    10501035            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    10511036                self.write_node(point, "dQl", datainfo.dxl[i], 
    1052                                 {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    1053         if datainfo.isSesans: 
    1054             sesans = self.create_element("Sesans") 
    1055             sesans.text = str(datainfo.isSesans) 
    1056             node.append(sesans) 
    1057             self.write_node(node, "zacceptance", datainfo.sample.zacceptance[0], 
    1058                              {'unit': datainfo.sample.zacceptance[1]}) 
    1059  
     1037                                {'unit': datainfo.x_unit}) 
    10601038 
    10611039    def _write_data_2d(self, 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/dataloader/readers/sesans_reader.py

    r9525358 r345e7e4  
    88import numpy 
    99import os 
    10 from sas.sascalc.dataloader.data_info import Data1D 
     10from sas.sascalc.dataloader.data_info import SESANSData1D 
    1111 
    1212# Check whether we have a converter available 
    … …  
    5959                    raise  RuntimeError, "sesans_reader: cannot open %s" % path 
    6060                buff = input_f.read() 
     61#                print buff 
    6162                lines = buff.splitlines() 
     63#                print lines 
     64                #Jae could not find python universal line spliter: 
     65                #keep the below for now 
     66                # some ascii data has \r line separator, 
     67                # try it when the data is on only one long line 
     68#                if len(lines) < 2 : 
     69#                    lines = buff.split('\r') 
     70                  
    6271                x  = numpy.zeros(0) 
    6372                y  = numpy.zeros(0) 
    … …  
    7483                tdlam = numpy.zeros(0) 
    7584                tdx = numpy.zeros(0) 
    76                 output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True) 
     85#                print "all good" 
     86                output = SESANSData1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam) 
     87#                print output                 
    7788                self.filename = output.filename = basename 
    7889 
     90#                #Initialize counters for data lines and header lines. 
     91#                is_data = False  # Has more than 5 lines 
     92#                # More than "5" lines of data is considered as actual 
     93#                # data unless that is the only data 
     94#                mum_data_lines = 5 
     95#                # To count # of current data candidate lines 
     96#                i = -1 
     97#                # To count total # of previous data candidate lines 
     98#                i1 = -1 
     99#                # To count # of header lines 
     100#                j = -1 
     101#                # Helps to count # of header lines 
     102#                j1 = -1 
     103#                #minimum required number of columns of data; ( <= 4). 
     104#                lentoks = 2 
    79105                paramnames=[] 
    80106                paramvals=[] 
    … …  
    85111                Pvals=[] 
    86112                dPvals=[] 
    87  
     113#                print x 
     114#                print zvals 
    88115                for line in lines: 
    89116                    # Initial try for CSV (split on ,) 
    … …  
    95122                    if len(toks)>5: 
    96123                        zvals.append(toks[0]) 
    97                         dzvals.append(toks[3]) 
    98                         lamvals.append(toks[4]) 
    99                         dlamvals.append(toks[5]) 
    100                         Pvals.append(toks[1]) 
    101                         dPvals.append(toks[2]) 
     124                        dzvals.append(toks[1]) 
     125                        lamvals.append(toks[2]) 
     126                        dlamvals.append(toks[3]) 
     127                        Pvals.append(toks[4]) 
     128                        dPvals.append(toks[5]) 
    102129                    else: 
    103130                        continue 
    … …  
    113140                default_z_unit = "A" 
    114141                data_conv_P = None 
    115                 default_p_unit = " " # Adjust unit for axis (L^-3) 
     142                default_p_unit = " " 
    116143                lam_unit = lam_header[1].replace("[","").replace("]","") 
    117                 if lam_unit == 'AA': 
    118                     lam_unit = 'A' 
    119144                varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]] 
    120145                valrange=range(1, len(zvals)) 
    … …  
    136161                output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit) 
    137162                output.y = y 
    138                 output.y_unit = r'\AA^{-2} cm^{-1}'  # output y_unit added 
    139163                output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit) 
    140164                output.dy = dy 
    141165                output.lam, output.lam_unit = self._unit_conversion(lam, lam_unit, default_z_unit) 
    142166                output.dlam, output.dlam_unit = self._unit_conversion(dlam, lam_unit, default_z_unit) 
    143                  
    144                 output.xaxis(r"\rm{z}", output.x_unit) 
    145                 output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", output.y_unit)  # Adjust label to ln P/(lam^2 t), remove lam column refs 
    146167 
     168                output.xaxis("\rm{z}", output.x_unit) 
     169                output.yaxis("\\rm{P/P0}", output.y_unit) 
    147170                # Store loading process information 
    148171                output.meta_data['loader'] = self.type_name 
    149                 #output.sample.thickness = float(paramvals[6]) 
     172                output.sample.thickness = float(paramvals[6]) 
    150173                output.sample.name = paramvals[1] 
    151174                output.sample.ID = paramvals[0] 
    152175                zaccept_unit_split = paramnames[7].split("[") 
    153176                zaccept_unit = zaccept_unit_split[1].replace("]","") 
    154                 if zaccept_unit.strip() == r'\AA^-1' or zaccept_unit.strip() == r'\A^-1': 
     177                if zaccept_unit.strip() == '\AA^-1': 
    155178                    zaccept_unit = "1/A" 
    156179                output.sample.zacceptance=(float(paramvals[7]),zaccept_unit) 
    157                 output.vars = varheader 
     180                output.vars=varheader 
    158181 
    159182                if len(output.x) < 1: 

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

    ra9f579c rd3911e3  
    131131        a way to get residuals from data. 
    132132    """ 
    133     def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None, lam=None, dlam=None): 
     133    def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None): 
    134134        """ 
    135135            :param smearer: is an object of class QSmearer or SlitSmearer 
    … …  
    152152                 
    153153        """ 
    154         Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy, lam=lam, dlam=dlam) 
     154        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy) 
    155155        self.num_points = len(x) 
    156156        self.sas_data = data 

  • 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/CategoryInstaller.py

    rddbac66 r212bfc2  
    123123        compile it and install 
    124124        :param homefile: Override the default home directory 
    125         :param model_list: List of model names except those in Plugin Models 
    126                which are user supplied. 
     125        :param model_list: List of model names except customized models 
    127126        """ 
    128127        _model_dict = { model.name: model for model in model_list} 

  • 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/guiframe/dataFitting.py

    r68adf86 r345e7e4  
    1717    """ 
    1818    """ 
    19  
    20     def __init__(self, x=None, y=None, dx=None, dy=None, lam=None, dlam=None, isSesans=False): 
     19    def __init__(self, x=None, y=None, dx=None, dy=None): 
    2120        """ 
    2221        """ 
    … …  
    2524        if y is None: 
    2625            y = [] 
    27         self.isSesans = isSesans 
    28         PlotData1D.__init__(self, x, y, dx, dy, lam, dlam) 
    29         LoadData1D.__init__(self, x, y, dx, dy, lam, dlam, isSesans) 
    30  
     26        PlotData1D.__init__(self, x, y, dx, dy) 
     27        LoadData1D.__init__(self, x, y, dx, dy) 
    3128        self.id = None 
    3229        self.list_group_id = [] 
    … …  
    3532        self.path = None 
    3633        self.xtransform = None 
    37         if self.isSesans: 
    38             self.xtransform = "x" 
    3934        self.ytransform = None 
    40         if self.isSesans: 
    41             self.ytransform = "y" 
    4235        self.title = "" 
    4336        self.scale = None 
    … …  
    7568        # First, check the data compatibility 
    7669        dy, dy_other = self._validity_check(other) 
    77         result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=None) 
     70        result = Data1D(x=[], y=[], dx=None, dy=None) 
    7871        result.clone_without_data(length=len(self.x), clone=self) 
    7972        result.copy_from_datainfo(data1d=self) 
    … …  
    122115        # First, check the data compatibility 
    123116        self._validity_check_union(other) 
    124         result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=None) 
     117        result = Data1D(x=[], y=[], dx=None, dy=None) 
    125118        tot_length = len(self.x) + len(other.x) 
    126119        result = self.clone_without_data(length=tot_length, clone=result) 
    127         if self.dlam == None or other.dlam is None: 
    128             result.dlam = None 
    129         else: 
    130             result.dlam = numpy.zeros(tot_length) 
    131120        if self.dy == None or other.dy is None: 
    132121            result.dy = None 
    … …  
    152141        result.y = numpy.append(self.y, other.y) 
    153142        result.y = result.y[ind] 
    154         result.lam = numpy.append(self.lam, other.lam) 
    155         result.lam = result.lam[ind] 
    156         if result.dlam != None: 
    157             result.dlam = numpy.append(self.dlam, other.dlam) 
    158             result.dlam = result.dlam[ind] 
    159143        if result.dy != None: 
    160144            result.dy = numpy.append(self.dy, other.dy) 
    … …  
    276260        # First, check the data compatibility 
    277261        self._validity_check_union(other) 
    278         result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=[]) 
     262        result = Data1D(x=[], y=[], dx=None, dy=None) 
    279263        tot_length = len(self.x)+len(other.x) 
    280264        result.clone_without_data(length=tot_length, clone=self) 
    281         if self.dlam == None or other.dlam is None: 
    282             result.dlam = None 
    283         else: 
    284             result.dlam = numpy.zeros(tot_length) 
    285265        if self.dy == None or other.dy is None: 
    286266            result.dy = None 
    … …  
    305285        result.y = numpy.append(self.y, other.y) 
    306286        result.y = result.y[ind] 
    307         result.lam = numpy.append(self.lam, other.lam) 
    308         result.lam = result.lam[ind] 
    309287        if result.dy != None: 
    310288            result.dy = numpy.append(self.dy, other.dy) 

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

    r2ffe241 r345e7e4  
    6161         
    6262        if issubclass(Data2D, data.__class__): 
    63             new_plot = Data2D(image=None, err_image=None) # For now, isSesans for 2D data is always false 
    64         else: 
    65             new_plot = Data1D(x=[], y=[], dx=None, dy=None, lam=None, dlam=None, isSesans=data.isSesans) 
    66  
    67  
    68         #elif data.meta_data['loader'] == 'SESANS': 
    69         #    new_plot = Data1D(x=[], y=[], dx=None, dy=None, lam=None, dlam=None, isSesans=True) 
    70         #else: 
    71         #    new_plot = Data1D(x=[], y=[], dx=None, dy=None, lam=None, dlam=None) #SESANS check??? 
    72  
     63            new_plot = Data2D(image=None, err_image=None)  
     64        else:  
     65            new_plot = Data1D(x=[], y=[], dx=None, dy=None) 
     66            
    7367        new_plot.copy_from_datainfo(data) 
    7468        data.clone_without_data(clone=new_plot) 

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

    ra45a298 rc8e1996  
    6666    IS_MAC = True 
    6767 
    68 STYLE_FLAG = (wx.RAISED_BORDER | CT.TR_HAS_BUTTONS | 
    69                     wx.WANTS_CHARS | CT.TR_HAS_VARIABLE_ROW_HEIGHT) 
     68STYLE_FLAG = wx.RAISED_BORDER | CT.TR_HAS_BUTTONS | CT.TR_HIDE_ROOT |\ 
     69                    wx.WANTS_CHARS | CT.TR_HAS_VARIABLE_ROW_HEIGHT 
    7070 
    7171 
    … …  
    7474    Check list control to be used for Data Panel 
    7575    """ 
    76     def __init__(self, parent, root, *args, **kwds): 
     76    def __init__(self, parent, *args, **kwds): 
    7777        # agwstyle is introduced in wx.2.8.11 but is not working for mac 
    7878        if IS_MAC and wx_version < 812: 
    … …  
    9797                    del kwds['style'] 
    9898                    CT.CustomTreeCtrl.__init__(self, parent, *args, **kwds) 
    99         self.root = self.AddRoot(root) 
     99        self.root = self.AddRoot("Available Data") 
    100100 
    101101    def OnCompareItems(self, item1, item2): 
    … …  
    520520        Add a listcrtl in the panel 
    521521        """ 
    522         # Add splitter 
    523         w, h = self.parent.GetSize() 
    524         splitter = wx.SplitterWindow(self) 
    525         splitter.SetMinimumPaneSize(50) 
    526         splitter.SetSashGravity(1.0) 
    527  
    528         file_sizer = wx.BoxSizer(wx.VERTICAL) 
    529         file_sizer.SetMinSize(wx.Size(w/13, h*2/5)) 
    530         theory_sizer = wx.BoxSizer(wx.VERTICAL) 
    531         theory_sizer.SetMinSize(wx.Size(w/13, h*2/5)) 
    532  
    533         self.tree_ctrl = DataTreeCtrl(parent=splitter, 
    534                                       style=wx.SUNKEN_BORDER, 
    535                                       root="Available Data") 
    536  
     522        tree_ctrl_label = wx.StaticText(self, -1, "Data") 
     523        tree_ctrl_label.SetForegroundColour('blue') 
     524        self.tree_ctrl = DataTreeCtrl(parent=self, style=wx.SUNKEN_BORDER) 
    537525        self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_CHECKING, self.on_check_item) 
    538526        self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_MENU, self.on_right_click_data) 
    … …  
    569557        wx.EVT_MENU(self, self.editmask_id, self.on_edit_data) 
    570558 
    571         self.tree_ctrl_theory = DataTreeCtrl(parent=splitter, 
    572                                              style=wx.SUNKEN_BORDER, 
    573                                              root="Available Theory") 
     559        tree_ctrl_theory_label = wx.StaticText(self, -1, "Theory") 
     560        tree_ctrl_theory_label.SetForegroundColour('blue') 
     561        self.tree_ctrl_theory = DataTreeCtrl(parent=self, 
     562                                             style=wx.SUNKEN_BORDER) 
    574563        self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_CHECKING, 
    575564                                   self.on_check_item) 
    576565        self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_MENU, 
    577566                                   self.on_right_click_theory) 
    578         splitter.SplitHorizontally(self.tree_ctrl, self.tree_ctrl_theory) 
    579         self.sizer1.Add(splitter, 1, wx.EXPAND | wx.ALL, 10) 
     567        self.sizer1.Add(tree_ctrl_label, 0, wx.LEFT, 10) 
     568        self.sizer1.Add(self.tree_ctrl, 1, wx.EXPAND | wx.ALL, 10) 
     569        self.sizer1.Add(tree_ctrl_theory_label, 0,  wx.LEFT, 10) 
     570        self.sizer1.Add(self.tree_ctrl_theory, 1, wx.EXPAND | wx.ALL, 10) 
    580571 
    581572    def on_right_click_theory(self, event): 
    … …  
    731722            if self.tree_ctrl.root: 
    732723                self.tree_ctrl.SortChildren(self.tree_ctrl.root) 
    733             # Expand root if # of data sets > 0 
    734             if self.tree_ctrl.GetCount() > 0: 
    735                 self.tree_ctrl.root.Expand() 
    736724        self.enable_remove() 
    737725        self.enable_import() 
    … …  
    772760                                       state_id=state_id, 
    773761                                       theory_list=theory_list) 
    774         if self.tree_ctrl_theory.GetCount() > 0: 
    775             self.tree_ctrl_theory.root.Expand() 
    776762 
    777763    def append_theory_helper(self, tree, root, state_id, theory_list): 

  • src/sas/sasgui/perspectives/calculator/model_editor.py

    rddbac66 ra08b89b  
    55function of y (usually the intensity).  It also provides a drop down of 
    66standard available math functions.  Finally a full python editor panel for 
    7 complete customization is provided. 
    8  
    9 :TODO the writing of the file and name checking (and maybe some other 
    10 functions?) should be moved to a computational module which could be called 
    11 from a python script.  Basically one just needs to pass the name, 
     7complete customizatin is provided. 
     8 
     9:TODO the writiong of the file and name checking (and maybe some other 
     10funtions?) should be moved to a computational module which could be called 
     11fropm a python script.  Basically one just needs to pass the name, 
    1212description text and function text (or in the case of the composite editor 
    1313the names of the first and second model and the operator to be used). 
    … …  
    6161    """ 
    6262    Dialog for easy custom composite models.  Provides a wx.Dialog panel 
    63     to choose two existing models (including pre-existing Plugin Models which 
     63    to choose two existing models (including pre-existing custom models which 
    6464    may themselves be composite models) as well as an operation on those models 
    6565    (add or multiply) the resulting model will add a scale parameter for summed 
    … …  
    380380            color = 'blue' 
    381381        except: 
    382             msg = "Easy Sum/Multipy Plugin: Error occurred..." 
     382            msg = "Easy Custom Sum/Multipy: Error occurred..." 
    383383            info = 'Error' 
    384384            color = 'red' 
    … …  
    501501        self.factor = factor 
    502502        self._operator = operator 
    503         self.explanation = "  Plugin Model = %s %s (model1 %s model2)\n" % \ 
     503        self.explanation = "  Custom Model = %s %s (model1 %s model2)\n" % \ 
    504504                           (self.factor, f_oper, self._operator) 
    505505        self.explanationctr.SetLabel(self.explanation) 
    … …  
    617617class EditorPanel(wx.ScrolledWindow): 
    618618    """ 
    619     Simple Plugin Model function editor 
     619    Custom model function editor 
    620620    """ 
    621621    def __init__(self, parent, base, path, title, *args, **kwds): 
    … …  
    652652        self.msg_sizer = None 
    653653        self.warning = "" 
    654         #This does not seem to be used anywhere so commenting out for now 
    655         #    -- PDB 2/26/17  
    656         #self._description = "New Plugin Model" 
     654        self._description = "New Custom Model" 
    657655        self.function_tcl = None 
    658656        self.math_combo = None 
    … …  
    993991        else: 
    994992            self._notes = result 
    995             msg = "Successful! Please look for %s in Plugin Models."%name 
     993            msg = "Successful! Please look for %s in Customized Models."%name 
    996994            msg += "  " + self._notes 
    997995            info = 'Info' 
    … …  
    11401138    def on_help(self, event): 
    11411139        """ 
    1142         Bring up the New Plugin Model Editor Documentation whenever 
     1140        Bring up the Custom Model Editor Documentation whenever 
    11431141        the HELP button is clicked. 
    11441142 
    … …  
    11921190        #self.Destroy() 
    11931191 
    1194 ## Templates for plugin models 
     1192## Templates for custom models 
    11951193 
    11961194CUSTOM_TEMPLATE = """ 

  • src/sas/sasgui/perspectives/calculator/pyconsole.py

    rddbac66 rd472e86  
    302302        success = show_model_output(self, fname) 
    303303 
    304         # Update plugin model list in fitpage combobox 
     304        # Update custom model list in fitpage combobox 
    305305        if success and self._manager != None and self.panel != None: 
    306306            self._manager.set_edit_menu_helper(self.parent) 

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

    rb301db9 r1a8e13f0  
    5353    ON_MAC = True 
    5454 
    55 CUSTOM_MODEL = 'Plugin Models' 
    56  
    5755class BasicPage(ScrolledPanel, PanelBase): 
    5856    """ 
    59     This class provide general structure of the fitpanel page 
     57    This class provide general structure of fitpanel page 
    6058    """ 
    6159    # Internal name for the AUI manager 
    … …  
    120118        self.dxw = None 
    121119        # pinhole smear 
    122         self.dx_percent = None 
     120        self.dx_min = None 
     121        self.dx_max = None 
    123122        # smear attrbs 
    124123        self.enable_smearer = None 
    … …  
    678677    def _copy_info(self, flag): 
    679678        """ 
    680         Send event depending on flag 
    681  
    682         : Param flag: flag that distinguishes the event 
     679        Send event dpemding on flag 
     680 
     681        : Param flag: flag that distinguish event 
    683682        """ 
    684683        # messages depending on the flag 
    … …  
    848847        self.state.pinhole_smearer = \ 
    849848                                copy.deepcopy(self.pinhole_smearer.GetValue()) 
    850         self.state.dx_percent = copy.deepcopy(self.dx_percent) 
     849        self.state.dx_max = copy.deepcopy(self.dx_max) 
     850        self.state.dx_min = copy.deepcopy(self.dx_min) 
    851851        self.state.dxl = copy.deepcopy(self.dxl) 
    852852        self.state.dxw = copy.deepcopy(self.dxw) 
    … …  
    11191119        :precondition: the page is already drawn or created 
    11201120 
    1121         :postcondition: the state of the underlying data changes as well as the 
     1121        :postcondition: the state of the underlying data change as well as the 
    11221122            state of the graphic interface 
    11231123        """ 
    … …  
    11671167        self._show_combox(None) 
    11681168        from models import PLUGIN_NAME_BASE 
    1169         if self.categorybox.GetValue() == CUSTOM_MODEL \ 
     1169        if self.categorybox.GetValue() == 'Customized Models' \ 
    11701170                and PLUGIN_NAME_BASE not in state.formfactorcombobox: 
    11711171            state.formfactorcombobox = \ 
    … …  
    12451245        # we have two more options for smearing 
    12461246        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) 
     1247            self.dx_min = state.dx_min 
     1248            self.dx_max = state.dx_max 
     1249            if self.dx_min is not None: 
     1250                self.smear_pinhole_min.SetValue(str(self.dx_min)) 
     1251            if self.dx_max is not None: 
     1252                self.smear_pinhole_max.SetValue(str(self.dx_max)) 
    12521253            self.onPinholeSmear(event=None) 
    12531254        elif self.slit_smearer.GetValue(): 
    … …  
    13341335    def _selectDlg(self): 
    13351336        """ 
    1336         open a dialog file to select the customized polydispersity function 
     1337        open a dialog file to selected the customized dispersity 
    13371338        """ 
    13381339        if self.parent is not None: 
    … …  
    17461747    def _set_multfactor_combobox(self, multiplicity=10): 
    17471748        """ 
    1748         Set comboBox for multitfactor of CoreMultiShellModel 
     1749        Set comboBox for muitfactor of CoreMultiShellModel 
    17491750        :param multiplicit: no. of multi-functionality 
    17501751        """ 
    … …  
    17841785        Fill panel's combo box according to the type of model selected 
    17851786        """ 
    1786  
     1787        custom_model = 'Customized Models' 
    17871788        mod_cat = self.categorybox.GetStringSelection() 
    17881789        self.structurebox.SetSelection(0) 
    … …  
    17931794        m_list = [] 
    17941795        try: 
    1795             if mod_cat == CUSTOM_MODEL: 
     1796            if mod_cat == custom_model: 
    17961797                for model in self.model_list_box[mod_cat]: 
    17971798                    m_list.append(self.model_dict[model.name]) 
    … …  
    34293430        fills out the category list box 
    34303431        """ 
    3431         uncat_str = 'Plugin Models' 
     3432        uncat_str = 'Customized Models' 
    34323433        self._read_category_info() 
    34333434 
    … …  
    34583459        self.model_box.Clear() 
    34593460 
    3460         if category == 'Plugin Models': 
     3461        if category == 'Customized Models': 
    34613462            for model in self.model_list_box[category]: 
    34623463                str_m = str(model).split(".")[0] 

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

    rd85f1d8a r1a8e13f0  
    2929_BOX_WIDTH = 76 
    3030_DATA_BOX_WIDTH = 300 
     31SMEAR_SIZE_L = 0.00 
    3132SMEAR_SIZE_H = 0.00 
    32 CUSTOM_MODEL = 'Plugin Models' 
     33 
    3334 
    3435class FitPage(BasicPage): 
    … …  
    163164        On_select_data 
    164165        """ 
    165         if self.dataSource.GetCount() > 0: 
    166             pos = self.dataSource.GetSelection() if event is not None else 0 
     166        if event is None and self.dataSource.GetCount() > 0: 
     167            data = self.dataSource.GetClientData(0) 
     168            self.set_data(data) 
     169        elif self.dataSource.GetCount() > 0: 
     170            pos = self.dataSource.GetSelection() 
    167171            data = self.dataSource.GetClientData(pos) 
    168172            self.set_data(data) 
    … …  
    209213              "Please enter only the value of interest to customize smearing..." 
    210214        smear_message_new_psmear = \ 
    211               "Please enter a fixed percentage to be applied to all Q values..." 
     215              "Please enter both; the dQ will be generated by interpolation..." 
    212216        smear_message_2d_x_title = "<dQp>[1/A]:" 
    213217        smear_message_2d_y_title = "<dQs>[1/A]:" 
    214         smear_message_pinhole_percent_title = "dQ[%]:" 
     218        smear_message_pinhole_min_title = "dQ_low[1/A]:" 
     219        smear_message_pinhole_max_title = "dQ_high[1/A]:" 
    215220        smear_message_slit_height_title = "Slit height[1/A]:" 
    216221        smear_message_slit_width_title = "Slit width[1/A]:" 
    … …  
    251256        self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting, 
    252257                  id=self.dI_idata.GetId()) 
    253         self.dI_noweight.SetValue(True) 
     258        self.dI_didata.SetValue(True) 
    254259        # add 4 types of weighting to the sizer 
    255260        sizer_weighting.Add(self.dI_noweight, 0, wx.LEFT, 10) 
    … …  
    261266        sizer_weighting.Add(self.dI_idata) 
    262267        sizer_weighting.Add((10, 10)) 
    263         self.dI_noweight.Enable(True) 
     268        self.dI_noweight.Enable(False) 
    264269        self.dI_didata.Enable(False) 
    265270        self.dI_sqrdata.Enable(False) 
    … …  
    305310         
    306311        # 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) 
     312        self.smear_pinhole_max = ModelTextCtrl(self, wx.ID_ANY, 
     313                            size=(_BOX_WIDTH - 25, 20), 
     314                            style=wx.TE_PROCESS_ENTER, 
     315                            text_enter_callback=self.onPinholeSmear) 
     316        self.smear_pinhole_min = ModelTextCtrl(self, wx.ID_ANY, 
     317                            size=(_BOX_WIDTH - 25, 20), 
     318                            style=wx.TE_PROCESS_ENTER, 
     319                            text_enter_callback=self.onPinholeSmear) 
    312320        self.smear_slit_height = ModelTextCtrl(self, wx.ID_ANY, 
    313321                            size=(_BOX_WIDTH - 25, 20), 
    … …  
    328336 
    329337        # set default values for smear 
    330         self.smear_pinhole_percent.SetValue(str(self.dx_percent)) 
     338        self.smear_pinhole_max.SetValue(str(self.dx_max)) 
     339        self.smear_pinhole_min.SetValue(str(self.dx_min)) 
    331340        self.smear_slit_height.SetValue(str(self.dxl)) 
    332341        self.smear_slit_width.SetValue(str(self.dxw)) 
    … …  
    353362        self.Bind(wx.EVT_RADIOBUTTON, self.onSlitSmear, 
    354363                  id=self.slit_smearer.GetId()) 
    355         self.disable_smearer.SetValue(True) 
     364        self.enable_smearer.SetValue(True) 
    356365 
    357366        sizer_smearer.Add(self.disable_smearer, 0, wx.LEFT, 10) 
    … …  
    420429        self.smear_description_2d_y.SetToolTipString( 
    421430                                    " 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) 
     431        self.smear_description_pin_min = wx.StaticText(self, wx.ID_ANY, 
     432                        smear_message_pinhole_min_title, style=wx.ALIGN_LEFT) 
     433        self.smear_description_pin_max = wx.StaticText(self, wx.ID_ANY, 
     434                        smear_message_pinhole_max_title, style=wx.ALIGN_LEFT) 
    425435        self.smear_description_slit_height = wx.StaticText(self, wx.ID_ANY, 
    426436                        smear_message_slit_height_title, style=wx.ALIGN_LEFT) 
    … …  
    446456        self.sizer_new_smear.Add((15, -1)) 
    447457        self.sizer_new_smear.Add(self.smear_description_2d_x, 0, wx.CENTER, 10) 
     458        self.sizer_new_smear.Add(self.smear_description_pin_min, 
     459                                 0, wx.CENTER, 10) 
    448460        self.sizer_new_smear.Add(self.smear_description_slit_height, 
    449461                                 0, wx.CENTER, 10) 
    450462 
     463        self.sizer_new_smear.Add(self.smear_pinhole_min, 0, wx.CENTER, 10) 
    451464        self.sizer_new_smear.Add(self.smear_slit_height, 0, wx.CENTER, 10) 
    452465        self.sizer_new_smear.Add(self.smear_data_left, 0, wx.CENTER, 10) 
    … …  
    454467        self.sizer_new_smear.Add(self.smear_description_2d_y, 
    455468                                 0, wx.CENTER, 10) 
    456         self.sizer_new_smear.Add(self.smear_description_pin_percent, 
     469        self.sizer_new_smear.Add(self.smear_description_pin_max, 
    457470                                 0, wx.CENTER, 10) 
    458471        self.sizer_new_smear.Add(self.smear_description_slit_width, 
    459472                                 0, wx.CENTER, 10) 
    460473 
    461         self.sizer_new_smear.Add(self.smear_pinhole_percent, 0, wx.CENTER, 10) 
     474        self.sizer_new_smear.Add(self.smear_pinhole_max, 0, wx.CENTER, 10) 
    462475        self.sizer_new_smear.Add(self.smear_slit_width, 0, wx.CENTER, 10) 
    463476        self.sizer_new_smear.Add(self.smear_data_right, 0, wx.CENTER, 10) 
    … …  
    12361249            wx.PostEvent(self.parent, new_event) 
    12371250            # update list of plugins if new plugin is available 
    1238             custom_model = CUSTOM_MODEL 
     1251            custom_model = 'Customized Models' 
    12391252            mod_cat = self.categorybox.GetStringSelection() 
    12401253            if mod_cat == custom_model: 
    … …  
    12581271            if copy_flag: 
    12591272                self.get_paste_params(copy_flag) 
    1260             wx.CallAfter(self._onDraw, None) 
     1273                wx.CallAfter(self._onDraw, None) 
    12611274 
    12621275        else: 
    … …  
    15711584        if self.dxw is None: 
    15721585            self.dxw = "" 
    1573         if self.dx_percent is None: 
    1574             self.dx_percent = SMEAR_SIZE_H 
     1586        if self.dx_min is None: 
     1587            self.dx_min = SMEAR_SIZE_L 
     1588        if self.dx_max is None: 
     1589            self.dx_max = SMEAR_SIZE_H 
    15751590 
    15761591    def _get_smear_info(self): 
    … …  
    16121627        elif data.dxl is not None or data.dxw is not None: 
    16131628            self.smear_type = "Slit" 
    1614             if data.dxl is not None and numpy.all(data.dxl, 0): 
     1629            if data.dxl is not None and not numpy.all(data.dxl, 0): 
    16151630                self.dq_l = data.dxl[0] 
    1616             if data.dxw is not None and numpy.all(data.dxw, 0): 
     1631            if data.dxw is not None and not numpy.all(data.dxw, 0): 
    16171632                self.dq_r = data.dxw[0] 
    16181633        # return self.smear_type,self.dq_l,self.dq_r 
    … …  
    16341649            self.smear_description_2d_y.Show(True) 
    16351650            if self.pinhole_smearer.GetValue(): 
    1636                 self.smear_pinhole_percent.Show(True) 
     1651                self.smear_pinhole_min.Show(True) 
     1652                self.smear_pinhole_max.Show(True) 
    16371653        # smear from data 
    16381654        elif self.enable_smearer.GetValue(): 
    … …  
    16451661                    self.smear_description_slit_width.Show(True) 
    16461662                elif self.smear_type == 'Pinhole': 
    1647                     self.smear_description_pin_percent.Show(True) 
     1663                    self.smear_description_pin_min.Show(True) 
     1664                    self.smear_description_pin_max.Show(True) 
    16481665                self.smear_description_smear_type.Show(True) 
    16491666                self.smear_description_type.Show(True) 
    … …  
    16541671            if self.smear_type == 'Pinhole': 
    16551672                self.smear_message_new_p.Show(True) 
    1656                 self.smear_description_pin_percent.Show(True) 
    1657  
    1658             self.smear_pinhole_percent.Show(True) 
     1673                self.smear_description_pin_min.Show(True) 
     1674                self.smear_description_pin_max.Show(True) 
     1675 
     1676            self.smear_pinhole_min.Show(True) 
     1677            self.smear_pinhole_max.Show(True) 
    16591678        # custom slit smear 
    16601679        elif self.slit_smearer.GetValue(): 
    … …  
    16811700        self.smear_data_left.Hide() 
    16821701        self.smear_data_right.Hide() 
    1683         self.smear_description_pin_percent.Hide() 
    1684         self.smear_pinhole_percent.Hide() 
     1702        self.smear_description_pin_min.Hide() 
     1703        self.smear_pinhole_min.Hide() 
     1704        self.smear_description_pin_max.Hide() 
     1705        self.smear_pinhole_max.Hide() 
    16851706        self.smear_description_slit_height.Hide() 
    16861707        self.smear_slit_height.Hide() 
    … …  
    19061927 
    19071928            # more disables for 2D 
    1908             di_flag = False 
    1909             dq_flag = False 
    19101929            if self.data.__class__.__name__ == "Data2D" or \ 
    19111930                        self.enable2D: 
    … …  
    19131932                self.pinhole_smearer.Enable(True) 
    19141933                self.default_mask = copy.deepcopy(self.data.mask) 
    1915                 if self.data.err_data is not None \ 
    1916                         and numpy.any(self.data.err_data): 
    1917                     di_flag = True 
    1918                 if self.data.dqx_data is not None \ 
    1919                         and numpy.any(self.data.dqx_data): 
    1920                     dq_flag = True 
     1934                if self.data.err_data is None or\ 
     1935                        numpy.all(err == 1 for err in self.data.err_data) or \ 
     1936                        not numpy.any(self.data.err_data): 
     1937                    self.dI_didata.Enable(False) 
     1938                    self.dI_noweight.SetValue(True) 
     1939                    self.weightbt_string = self.dI_noweight.GetLabelText() 
     1940                else: 
     1941                    self.dI_didata.Enable(True) 
     1942                    self.dI_didata.SetValue(True) 
     1943                    self.weightbt_string = self.dI_didata.GetLabelText() 
    19211944            else: 
    19221945                self.slit_smearer.Enable(True) 
    19231946                self.pinhole_smearer.Enable(True) 
    1924                 if self.data.dy is not None and numpy.any(self.data.dy): 
    1925                     di_flag = True 
    1926                 if self.data.dx is not None and numpy.any(self.data.dx): 
    1927                     dq_flag = True 
    1928                 elif self.data.dxl is not None and numpy.any(self.data.dxl): 
    1929                     dq_flag = True 
    1930  
    1931             if dq_flag: 
    1932                 self.enable_smearer.Enable(True) 
    1933                 self.enable_smearer.SetValue(True) 
    1934                 self.disable_smearer.SetValue(False) 
    1935             else: 
    1936                 self.enable_smearer.Disable() 
    1937                 self.disable_smearer.Enable(True) 
    1938                 self.disable_smearer.SetValue(True) 
    1939  
    1940             if di_flag: 
    1941                 self.dI_didata.Enable(True) 
    1942                 self.dI_didata.SetValue(True) 
    1943                 self.weightbt_string = self.dI_didata.GetLabelText() 
    1944             else: 
    1945                 self.dI_didata.Enable(False) 
    1946                 self.dI_noweight.SetValue(True) 
    1947                 self.weightbt_string = self.dI_noweight.GetLabelText() 
    1948  
     1947 
     1948                if self.data.dy is None or\ 
     1949                     numpy.all(self.data.dy == 1) or\ 
     1950                     not numpy.any(self.data.dy): 
     1951                    self.dI_didata.Enable(False) 
     1952                    self.dI_noweight.SetValue(True) 
     1953                    self.weightbt_string = self.dI_noweight.GetLabelText() 
     1954                else: 
     1955                    self.dI_didata.Enable(True) 
     1956                    self.dI_didata.SetValue(True) 
     1957                    self.weightbt_string = self.dI_didata.GetLabelText() 
    19491958            # Enable weighting radio buttons 
    19501959            self.dI_noweight.Enable(True) 
    … …  
    19881997            self.EditMask_title.Disable() 
    19891998 
    1990         self.on_smear_helper() 
    19911999        self.on_set_focus(None) 
    19922000        self.Refresh() 
    … …  
    22202228            # event case of radio button 
    22212229            if tcrtl.GetValue(): 
    2222                 self.dx_percent = 0.0 
     2230                self.dx_min = 0.0 
     2231                self.dx_max = 0.0 
    22232232                is_new_pinhole = True 
    22242233            else: 
    … …  
    22572266        """ 
    22582267        # get the values 
    2259         pin_percent = self.smear_pinhole_percent.GetValue() 
     2268        pin_min = self.smear_pinhole_min.GetValue() 
     2269        pin_max = self.smear_pinhole_max.GetValue() 
     2270 
     2271        # Check changes in slit width 
     2272        try: 
     2273            dx_min = float(pin_min) 
     2274        except: 
     2275            return True 
     2276        if self.dx_min != dx_min: 
     2277            return True 
    22602278 
    22612279        # Check changes in slit heigth 
    22622280        try: 
    2263             dx_percent = float(pin_percent) 
     2281            dx_max = float(pin_max) 
    22642282        except: 
    22652283            return True 
    2266         if self.dx_percent != dx_percent: 
     2284        if self.dx_max != dx_max: 
    22672285            return True 
    22682286        return False 
    … …  
    22902308        msg = None 
    22912309 
    2292         get_pin_percent = self.smear_pinhole_percent 
    2293  
    2294         if not check_float(get_pin_percent): 
    2295             get_pin_percent.SetBackgroundColour("pink") 
     2310        get_pin_min = self.smear_pinhole_min 
     2311        get_pin_max = self.smear_pinhole_max 
     2312 
     2313        if not check_float(get_pin_min): 
     2314            get_pin_min.SetBackgroundColour("pink") 
     2315            msg = "Model Error:wrong value entered!!!" 
     2316        elif not check_float(get_pin_max): 
     2317            get_pin_max.SetBackgroundColour("pink") 
    22962318            msg = "Model Error:wrong value entered!!!" 
    22972319        else: 
    22982320            if len_data < 2: 
    22992321                len_data = 2 
    2300             self.dx_percent = float(get_pin_percent.GetValue()) 
    2301             if self.dx_percent < 0: 
    2302                 get_pin_percent.SetBackgroundColour("pink") 
     2322            self.dx_min = float(get_pin_min.GetValue()) 
     2323            self.dx_max = float(get_pin_max.GetValue()) 
     2324            if self.dx_min < 0: 
     2325                get_pin_min.SetBackgroundColour("pink") 
    23032326                msg = "Model Error:This value can not be negative!!!" 
    2304             elif self.dx_percent is not None: 
    2305                 percent = self.dx_percent/100 
     2327            elif self.dx_max < 0: 
     2328                get_pin_max.SetBackgroundColour("pink") 
     2329                msg = "Model Error:This value can not be negative!!!" 
     2330            elif self.dx_min is not None and self.dx_max is not None: 
    23062331                if self._is_2D(): 
    2307                     data.dqx_data[data.dqx_data == 0] = percent * data.qx_data 
    2308                     data.dqy_data[data.dqy_data == 0] = percent * data.qy_data 
     2332                    data.dqx_data[data.dqx_data == 0] = self.dx_min 
     2333                    data.dqy_data[data.dqy_data == 0] = self.dx_max 
     2334                elif self.dx_min == self.dx_max: 
     2335                    data.dx[data.dx == 0] = self.dx_min 
    23092336                else: 
    2310                     data.dx = percent * data.x 
     2337                    step = (self.dx_max - self.dx_min) / (len_data - 1) 
     2338                    data.dx = numpy.arange(self.dx_min, 
     2339                                           self.dx_max + step / 1.1, 
     2340                                           step) 
     2341            elif self.dx_min is not None: 
     2342                if self._is_2D(): 
     2343                    data.dqx_data[data.dqx_data == 0] = self.dx_min 
     2344                else: 
     2345                    data.dx[data.dx == 0] = self.dx_min 
     2346            elif self.dx_max is not None: 
     2347                if self._is_2D(): 
     2348                    data.dqy_data[data.dqy_data == 0] = self.dx_max 
     2349                else: 
     2350                    data.dx[data.dx == 0] = self.dx_max 
    23112351            self.current_smearer = smear_selection(data, self.model) 
    23122352            # 2D need to set accuracy 
    … …  
    23182358            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    23192359        else: 
    2320             get_pin_percent.SetBackgroundColour("white") 
     2360            get_pin_min.SetBackgroundColour("white") 
     2361            get_pin_max.SetBackgroundColour("white") 
    23212362        # set smearing value whether or not the data contain the smearing info 
    23222363 

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

    r4c5098c r1a8e13f0  
    225225 
    226226        self.id_edit = wx.NewId() 
     227        editmodel_help = "Edit customized model sample file" 
    227228        self.menu1.AppendMenu(self.id_edit, "Plugin Model Operations", 
    228                               self.edit_model_menu) 
     229                              self.edit_model_menu, editmodel_help) 
    229230        #create  menubar items 
    230231        return [(self.menu1, self.sub_menu)] 
    … …  
    259260            self.update_custom_combo() 
    260261            if os.path.isfile(p_path): 
    261                 msg = "Sorry! unable to delete the default " 
    262                 msg += "plugin model... \n" 
     262                msg = "Sorry! Could not be able to delete the default " 
     263                msg += "custom model... \n" 
    263264                msg += "Please manually remove the files (.py, .pyc) " 
    264265                msg += "in the 'plugin_models' folder \n" 
    … …  
    273274                    if item.GetLabel() == label: 
    274275                        self.edit_menu.DeleteItem(item) 
    275                         msg = "The plugin model, %s, has been deleted." % label 
     276                        msg = "The custom model, %s, has been deleted." % label 
    276277                        evt = StatusEvent(status=msg, type='stop', info='info') 
    277278                        wx.PostEvent(self.parent, evt) 
    … …  
    330331            temp = self.fit_panel.reset_pmodel_list() 
    331332            if temp: 
    332                 # Set the new plugin model list for all fit pages 
     333                # Set the new custom model list for all fit pages 
    333334                for uid, page in self.fit_panel.opened_pages.iteritems(): 
    334335                    if hasattr(page, "formfactorbox"): 
    … …  
    17451746                                          data_id="Data  " + data.name + " unsmeared", 
    17461747                                          dy=unsmeared_error) 
    1747             # Comment this out until we can get P*S models with correctly populated parameters 
    1748             #if sq_model is not None and pq_model is not None: 
    1749             #    self.create_theory_1D(x, sq_model, page_id, model, data, state, 
    1750             #                          data_description=model.name + " S(q)", 
    1751             #                          data_id=str(page_id) + " " + data.name + " S(q)") 
    1752             #    self.create_theory_1D(x, pq_model, page_id, model, data, state, 
    1753             #                          data_description=model.name + " P(q)", 
    1754             #                          data_id=str(page_id) + " " + data.name + " P(q)") 
     1748                 
     1749            if sq_model is not None and pq_model is not None: 
     1750                self.create_theory_1D(x, sq_model, page_id, model, data, state, 
     1751                                      data_description=model.name + " S(q)", 
     1752                                      data_id=str(page_id) + " " + data.name + " S(q)") 
     1753                self.create_theory_1D(x, pq_model, page_id, model, data, state, 
     1754                                      data_description=model.name + " P(q)", 
     1755                                      data_id=str(page_id) + " " + data.name + " P(q)") 
     1756 
    17551757 
    17561758            current_pg = self.fit_panel.get_page_by_id(page_id) 
    … …  
    19531955                ## then kill itself but cannot.  Paul Kienzle came up with 
    19541956                ## this fix to prevent threads from stepping on each other 
    1955                 ## which was causing a simple custom plugin model to crash 
    1956                 ##Sasview. 
     1957                ## which was causing a simple custom model to crash Sasview. 
    19571958                ## We still don't know why the fit sometimes lauched a second 
    19581959                ## thread -- something which should also be investigated. 

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

    r5295cf5 r26c8be3  
    3434*  in *Single* fit mode - individual data sets are fitted independently one-by-one 
    3535 
    36 *  in *Simultaneous* fit mode - multiple data sets are fitted simultaneously to 
    37    the *same* model with/without constrained parameters (this might be useful, 
    38    for example, if you have measured the same sample at different contrasts) 
     36*  in *Simultaneous* fit mode - multiple data sets are fitted simultaneously to the *same* model with/without constrained parameters (this might be useful, for example, if you have measured the same sample at different contrasts) 
    3937 
    4038*  in *Batch* fit mode - multiple data sets are fitted sequentially to the *same* model (this might be useful, for example, if you have performed a kinetic or time-resolved experiment and have *lots* of data sets!) 
    … …  
    4543----------------- 
    4644 
    47 The models in SasView are grouped into categories. By default these consist of: 
    48  
    49 *  *Cylinder* - cylindrical shapes (disc, right cylinder, cylinder with endcaps 
    50    etc) 
    51 *  *Ellipsoid* - ellipsoidal shapes (oblate,prolate, core shell, etc) 
    52 *  *Parellelepiped* - as the name implies 
    53 *  *Sphere* - sheroidal shapes (sphere, core multishell, vesicle, etc) 
    54 *  *Lamellae* - lamellar shapes (lamellar, core shell lamellar, stacked 
    55    lamellar, etc) 
     45By default, the models in SasView are grouped into five categories 
     46 
     47*  *Shapes* - models describing 'objects' (spheres, cylinders, etc) 
    5648*  *Shape-Independent* - models describing structure in terms of density correlation functions, fractals, peaks, power laws, etc 
    57 *  *Paracrystal* - semi ordered structures (bcc, fcc, etc) 
     49*  *Customized Models* - SasView- or User-created (non-library) Python models 
     50*  *Uncategorised* - other models (for reflectivity, etc) 
    5851*  *Structure Factor* - S(Q) models 
    59 *  *Plugin Models* - User-created (custom/non-library) Python models 
    6052 
    6153Use the *Category* drop-down menu to chose a category of model, then select 
    … …  
    9284.. image:: cat_fig0.bmp 
    9385 
    94 The categorization of all models except the user supplied Plugin Models can be 
    95 reassigned, added to, and removed using *Category Manager*. Models can also be 
    96 hidden from view in the drop-down menus. 
     86The categorization of all models except the customized models can be reassigned, 
     87added to, and removed using *Category Manager*. Models can also be hidden from view 
     88in the drop-down menus. 
    9789 
    9890.. image:: cat_fig1.bmp 
    … …  
    10193^^^^^^^^^^^^^^^^^ 
    10294 
    103 To change category, highlight a model in the list by left-clicking on its entry 
    104 and then click the *Modify* button. Use the *Change Category* panel that appears 
    105 to make the required changes. 
     95To change category, highlight a model in the list by left-clicking on its entry and 
     96then click the *Modify* button. Use the *Change Category* panel that appears to make 
     97the required changes. 
    10698 
    10799.. image:: cat_fig2.bmp 
    … …  
    114106^^^^^^^^^^^^^^^^^^^^^ 
    115107 
    116 Use the *Enable All / Disable All* buttons and the check boxes beside each model 
    117 to select the models to show/hide. To apply the selection, click *Ok*. Otherwise 
    118 click *Cancel*. 
     108Use the *Enable All / Disable All* buttons and the check boxes beside each model to 
     109select the models to show/hide. To apply the selection, click *Ok*. Otherwise click 
     110*Cancel*. 
    119111 
    120112*NB: It may be necessary to change to a different category and then back again* 
    … …  
    126118--------------- 
    127119 
    128 For a complete list of all the library models available in SasView, see 
    129 the `Model Documentation <../../../index.html>`_ . 
     120For a complete list of all the library models available in SasView, see the `Model Documentation <../../../index.html>`_ . 
    130121 
    131122It is also possible to add your own models. 
    … …  
    140131There are essentially three ways to generate new fitting models for SasView: 
    141132 
    142 *  Using the SasView :ref:`New_Plugin_Model` helper dialog (best for beginners 
    143    and/or relatively simple models) 
    144 *  By copying/editing an existing model (this can include models generated by 
    145    the New Plugin Model* dialog) in the :ref:`Python_shell` or  
    146    :ref:`Advanced_Plugin_Editor` (suitable for all use cases) 
    147 *  By writing a model from scratch outside of SasView (only recommended for code 
    148    monkeys!) 
     133* Using the SasView :ref:`New_Plugin_Model` helper dialog (best for beginners and/or relatively simple models) 
     134* By copying/editing an existing model (this can include models generated by the *New Plugin Model* dialog) in the :ref:`Python_shell` or :ref:`Advanced_Plugin_Editor` (suitable for all use cases) 
     135* By writing a model from scratch outside of SasView (only recommended for code monkeys!) 
    149136 
    150137Please read the guidance on :ref:`Writing_a_Plugin` before proceeding. 
    … …  
    176163^^^^^^^^^^^^^^^^ 
    177164 
    178 Relatively straightforward models can be programmed directly from the SasView 
    179 GUI using the *New Plugin Model Function*. 
     165Relatively straightforward models can be programmed directly from the SasView GUI  
     166using the *New Plugin Model Function*. 
    180167 
    181168.. image:: new_model.bmp 
    … …  
    188175*checked*\ . 
    189176 
    190 Also note that the 'Fit Parameters' have been split into two sections: those 
    191 which can be polydisperse (shape and orientation parameters) and those which are 
    192 not (eg, scattering length densities). 
     177Also note that the 'Fit Parameters' have been split into two sections: those which  
     178can be polydisperse (shape and orientation parameters) and those which are not 
     179(eg, scattering length densities). 
    193180 
    194181A model file generated by this option can be viewed and further modified using 
    … …  
    200187.. image:: sum_model.bmp 
    201188 
    202 This option creates a custom Plugin Model of the form:: 
    203  
    204      Plugin Model = scale_factor * {(scale_1 * model_1) +/- (scale_2 * model_2)} + background 
     189This option creates a custom model of the form:: 
     190 
     191     Custom Model = scale_factor \* {(scale_1 \* model_1) \+ (scale_2 \* model_2)} \+ background 
    205192 
    206193or:: 
    207194 
    208      Plugin Model = scale_factor * model_1 /* model_2 + background 
     195     Custom Model = scale_factor \* model_1 \* model_2 \+ background 
    209196 
    210197In the *Easy Sum/Multi Editor* give the new model a function name and brief 
    … …  
    245232Simply highlight the plugin model to be removed. The operation is final!!! 
    246233 
    247 *NB: Models shipped with SasView cannot be removed in this way.* 
     234*NB: Plugin models shipped with SasView cannot be removed in this way.* 
    248235 
    249236Load Plugin Models 
    250237^^^^^^^^^^^^^^^^^^ 
    251238 
    252 This option loads (or re-loads) all models present in the 
    253 *~\\.sasview\\plugin_models* folder. 
     239This option loads (or re-loads) all models present in the *~\\.sasview\\plugin_models* folder. 
    254240 
    255241.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 
    … …  
    414400:ref:`Assessing_Fit_Quality`. 
    415401 
    416 *NB: If you need to use a custom Plugin Model, you must ensure that model is 
    417 available first (see* :ref:`Adding_your_own_models` *).* 
     402*NB: If you need to use a customized model, you must ensure that model is available* 
     403*first (see* :ref:`Adding_your_own_models` *).* 
    418404 
    419405Method 
    … …  
    498484If multiple data sets are in one file, load just that file. *Unselect All Data*, then 
    499485select a single initial data set to be fitted. Fit that selected data set as described 
    500 above under :ref:`Single_Fit_Mode`. 
    501  
    502 *NB: If you need to use a custom Plugin Model, you must ensure that model is 
    503 available first (see* :ref:`Adding_your_own_models` *).* 
     486above under :ref:`Single_Fit_Mode` . 
     487 
     488*NB: If you need to use a customized model, you must ensure that model is available* 
     489*first (see* :ref:`Adding_your_own_models` *).* 
    504490 
    505491Method 

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

    r984f3fc rca6cbc1c  
    2727 
    2828the next time SasView is started it will compile the plugin and add 
    29 it to the list of *Plugin Models* in a FitPage. 
     29it to the list of *Customized Models* in a FitPage. 
    3030 
    3131SasView models can be of three types: 
    … …  
    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/model_thread.py

    rc1c9929 rc1681ea  
    177177            unsmeared_output = numpy.zeros((len(self.data.x))) 
    178178            unsmeared_output[first_bin:last_bin+1] = self.model.evalDistribution(mask) 
    179             self.smearer.model = self.model 
    180179            output = self.smearer(unsmeared_output, first_bin, last_bin) 
    181180 

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

    re92a352 r0de74af  
    325325                    self.plugins.append(plug) 
    326326                    self.model_dictionary[name] = plug 
    327             self.model_combobox.set_list("Plugin Models", self.plugins) 
     327            self.model_combobox.set_list("Customized Models", self.plugins) 
    328328            return self.model_combobox.get_list() 
    329329        else: 
    … …  
    346346            self.model_dictionary[name] = plug 
    347347 
    348         self.model_combobox.reset_list("Plugin Models", self.plugins) 
     348        self.model_combobox.reset_list("Customized Models", self.plugins) 
    349349        return self.model_combobox.get_list() 
    350350 
    … …  
    389389#                                     self.shape_indep_list) 
    390390        self.model_combobox.set_list("Structure Factors", self.struct_list) 
    391         self.model_combobox.set_list("Plugin Models", self.plugins) 
     391        self.model_combobox.set_list("Customized Models", self.plugins) 
    392392        self.model_combobox.set_list("P(Q)*S(Q)", self.multiplication_factor) 
    393393        self.model_combobox.set_list("multiplication", 

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

    r27109e5 r6d2b50b  
    3333from sas.sascalc.dataloader.data_info import Data2D, Collimation, Detector 
    3434from sas.sascalc.dataloader.data_info import Process, Aperture 
    35  
    3635# Information to read/write state as xml 
    3736FITTING_NODE_NAME = 'fitting_plug_in' 
    3837CANSAS_NS = "cansas1d/1.0" 
    39  
    40 CUSTOM_MODEL = 'Plugin Models' 
    41 CUSTOM_MODEL_OLD = 'Customized Models' 
    4238 
    4339LIST_OF_DATA_ATTRIBUTES = [["is_data", "is_data", "bool"], 
    … …  
    7470                            ["dq_l", "dq_l", "float"], 
    7571                            ["dq_r", "dq_r", "float"], 
    76                             ["dx_percent", "dx_percent", "float"], 
     72                            ["dx_max", "dx_max", "float"], 
     73                            ["dx_min", "dx_min", "float"], 
    7774                            ["dxl", "dxl", "float"], 
    7875                            ["dxw", "dxw", "float"]] 
    … …  
    214211        self.dq_l = None 
    215212        self.dq_r = None 
    216         self.dx_percent = None 
    217         self.dx_old = False 
     213        self.dx_max = None 
     214        self.dx_min = None 
    218215        self.dxl = None 
    219216        self.dxw = None 
    … …  
    342339        obj.dq_l = copy.deepcopy(self.dq_l) 
    343340        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) 
     341        obj.dx_max = copy.deepcopy(self.dx_max) 
     342        obj.dx_min = copy.deepcopy(self.dx_min) 
    346343        obj.dxl = copy.deepcopy(self.dxl) 
    347344        obj.dxw = copy.deepcopy(self.dxw) 
    … …  
    369366        :return: None 
    370367        """ 
    371         if self.categorycombobox == CUSTOM_MODEL_OLD: 
    372             self.categorycombobox = CUSTOM_MODEL 
    373368        if self.formfactorcombobox == '': 
    374369            FIRST_FORM = { 
    … …  
    383378                'Sphere' : 'adsorbed_layer', 
    384379                'Structure Factor' : 'hardsphere', 
    385                 CUSTOM_MODEL : '' 
     380                'Customized Models' : '' 
    386381            } 
    387382            if self.categorycombobox == '': 
    … …  
    561556        rep += "dq_l  : %s\n" % self.dq_l 
    562557        rep += "dq_r  : %s\n" % self.dq_r 
    563         rep += "dx_percent  : %s\n" % str(self.dx_percent) 
     558        rep += "dx_max  : %s\n" % str(self.dx_max) 
     559        rep += "dx_min : %s\n" % str(self.dx_min) 
    564560        rep += "dxl  : %s\n" % str(self.dxl) 
    565561        rep += "dxw : %s\n" % str(self.dxw) 
    … …  
    819815 
    820816        attr = newdoc.createAttribute("version") 
    821         from sas import sasview 
     817        import sasview 
    822818        attr.nodeValue = sasview.__version__ 
    823819        # attr.nodeValue = '1.0' 
    … …  
    10461042                    setattr(self, item[0], parse_entry_helper(node, item)) 
    10471043 
    1048                 dx_old_node = get_content('ns:%s' % 'dx_min', entry) 
    10491044                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)) 
     1045                    node = get_content('ns:%s' % item[0], entry) 
     1046                    setattr(self, item[0], parse_entry_helper(node, item)) 
    10581047 
    10591048                for item in LIST_OF_STATE_PARAMETERS: 

  • src/sas/sasgui/plottools/plottables.py

    ra9f579c r345e7e4  
    10231023    """ 
    10241024 
    1025     def __init__(self, x, y, dx=None, dy=None, lam=None, dlam=None): 
     1025    def __init__(self, x, y, dx=None, dy=None): 
    10261026        """ 
    10271027        Draw points specified by x[i],y[i] in the current color/symbol. 
    … …  
    10371037        self.x = x 
    10381038        self.y = y 
    1039         self.lam = lam 
    10401039        self.dx = dx 
    10411040        self.dy = dy 
    1042         self.dlam = dlam 
    10431041        self.source = None 
    10441042        self.detector = None 
Note: See TracChangeset for help on using the changeset viewer.