Changeset 5156918 in sasview


Ignore:
Timestamp:
Mar 31, 2017 5:20:15 AM (2 years ago)
Author:
wojciech
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
7b15990
Parents:
1a8e13f0 (diff), 7cbbacd (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' of https://github.com/SasView/sasview into ticket-854

Files:
1 added
1 deleted
30 edited
1 moved

Legend:

Unmodified
Added
Removed
  • INSTALL.txt

    rd09f0ae1 r26c9b85  
    22================================ 
    33 
     4Note - at the current time sasview will only run in gui form under Python 2. 
    45 
    5 The build works in the usualy pythonic way: 
     6Before trying to install and run sasview you'll need to check what 
     7dependencies are required: 
     8 
     9$ python check_packages.py 
     10 
     11Many of these are available from PyPi, but some (e.g. h5py) may require more 
     12involvement to build and install. If you use the conda package manager then 
     13many of the pre-built dependencies are available there. This may be the easiest 
     14route if you are on windows. 
     15 
     16The build works in the pythonic way: 
    617 
    718$ python setup.py build      # will build the package underneath 'build/' 
    8 $ python setup.py install    # will install the package 
    9  
     19$ python setup.py install    # will install the package into site-packages 
    1020 
    1121 
     
    1424$ python run.py              # will run the code in place (building the C code once, if required) 
    1525 
     26On OSX or windows you may need to use: 
    1627 
    17  
    18 To check all dependencies are met: 
    19  
    20 $ python deps.py 
    21 $ python check_packages.py  
    22  
    23 Both tell you different parts of the story, unfortunately. 
    24  
     28$ pythonw run.py 
    2529 
    2630 
  • LICENSE.TXT

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

    r220b1e7 r9146ed9  
    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 
    663    - New in Version 4.0.1 
    764      ------------------ 
     
    426483=============== 
    427484 
     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    
    428523   3.1- All systems: 
    429524        - The documentation window may take a few seconds to load the first time 
  • sasview/local_config.py

    r73cbeec rf9d1f60  
    3333''' remember to:''' 
    3434_acknowledgement_preamble_bullet1 =\ 
    35 '''Acknowledge its use in your publications as suggested below;''' 
     35'''Acknowledge its use in your publications as :''' 
    3636_acknowledgement_preamble_bullet2 =\ 
    37 '''Reference SasView as : M. Doucet, et al. SasView Version 4.0, Zenodo''' +\ 
    38 ''', http://doi.org/10.5281/zenodo.159083;''' 
     37'''Reference SasView as:''' 
    3938_acknowledgement_preamble_bullet3 =\ 
    40 '''Reference the model you used if appropriate (see documentation for refs);''' 
     39'''Reference the model you used if appropriate (see documentation for refs)''' 
    4140_acknowledgement_preamble_bullet4 =\ 
    4241'''Send us your reference for our records: developers@sasview.org''' 
    4342_acknowledgement_publications = \ 
    44 '''This work benefited from the use of the SasView application, originally developed under NSF Award  
    45 DMR-0520547. SasView also contains code developed with funding from the EU Horizon 2020 programme  
    46 under the SINE2020 project Grant No 654000, and by Patrick O'Brien & Adam Washington.''' 
     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''' 
    4746 
    4847_acknowledgement =  \ 
    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  
    50 by a collaboration between UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft. SasView also contains code developed with funding from the  
    51 EU Horizon 2020 programme under the SINE2020 project (Grant No 654000), and by Patrick O'Brien (pycrust) and Adam Washington (corfunc-py).''' 
     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''' 
    5250 
    5351_homepage = "http://www.sasview.org" 
     
    8987_corner_image = os.path.join(icon_path, "angles_flat.png") 
    9088_welcome_image = os.path.join(icon_path, "SVwelcome.png") 
    91 _copyright = "(c) 2009 - 2016, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft" 
     89_copyright = "(c) 2009 - 2017, UTK, UMD, NIST, ORNL, ISIS, ESS, ILL, ANSTO and TU Delft" 
    9290marketplace_url = "http://marketplace.sasview.org/" 
    9391 
  • setup.py

    r18e7309 r27109e5  
    206206) 
    207207 
    208  
    209208# sas.sascalc.pr 
    210209srcdir  = os.path.join("src", "sas", "sascalc", "pr", "c_extensions") 
     
    229228                              ) ) 
    230229 
     230#sas.sascalc.corfunc 
     231package_dir["sas.sascalc.corfunc"] = os.path.join("src", "sas", "sascalc", "corfunc") 
     232packages.extend(["sas.sascalc.corfunc"]) 
     233 
    231234# sas.sascalc.fit 
    232235package_dir["sas.sascalc.fit"] = os.path.join("src", "sas", "sascalc", "fit") 
     
    237240package_dir["sas.sasgui.perspectives.pr"] = os.path.join("src", "sas", "sasgui", "perspectives", "pr") 
    238241packages.extend(["sas.sasgui.perspectives","sas.sasgui.perspectives.pr"]) 
    239 package_data["sas.sasgui.perspectives.pr"] = ['images/*'] 
     242package_data["sas.sasgui.perspectives.pr"] = ['media/*'] 
    240243 
    241244package_dir["sas.sasgui.perspectives.invariant"] = os.path.join("src", "sas", "sasgui", "perspectives", "invariant") 
     
    250253packages.extend(["sas.sasgui.perspectives", "sas.sasgui.perspectives.calculator"]) 
    251254package_data['sas.sasgui.perspectives.calculator'] = ['images/*', 'media/*'] 
     255 
     256package_dir["sas.sasgui.perspectives.corfunc"] = os.path.join("src", "sas", "sasgui", "perspectives", "corfunc") 
     257packages.extend(["sas.sasgui.perspectives.corfunc"]) 
     258package_data['sas.sasgui.perspectives.corfunc'] = ['media/*'] 
     259 
     260package_dir["sas.sasgui.perspectives.file_converter"] = os.path.join("src", "sas", "sasgui", "perspectives", "file_converter") 
     261packages.extend(["sas.sasgui.perspectives.file_converter"]) 
     262package_data['sas.sasgui.perspectives.file_converter'] = ['media/*'] 
    252263 
    253264# Data util 
     
    304315                               'test/1d_data/*', 
    305316                               'test/2d_data/*', 
     317                               'test/convertible_files/*', 
     318                               'test/coordinate_data/*', 
     319                               'test/image_data/*', 
     320                               'test/media/*', 
     321                               'test/other_files/*', 
    306322                               'test/save_states/*', 
    307                                'test/upcoming_formats/*', 
    308                                  'default_categories.json'] 
     323                               'test/sesans_data/*' 
     324                               ] 
    309325packages.append("sas.sasview") 
    310326 
  • src/sas/sascalc/calculator/slit_length_calculator.py

    rb699768 rbfba720  
    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 == None or self.x == None: 
     44        if self.y is None or self.x is None: 
    4545            return 
    4646        # set local variable 
     
    5454        y_sum = 0.0 
    5555        y_max = 0.0 
    56         ind = 0.0 
     56        ind = 0 
    5757 
    5858        # sum 10 or more y values until getting max_y, 
     
    7070        # defaults 
    7171        y_half_d = 0.0 
    72         ind = 0.0 
     72        ind = 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

    rd3911e3 r775e0b7  
    1414import sys 
    1515 
     16import numpy as np  # type: ignore 
     17from numpy import pi, exp # type:ignore 
     18 
    1619from sasmodels.resolution import Slit1D, Pinhole1D 
     20from sasmodels.sesans import SesansTransform 
    1721from sasmodels.resolution2d import Pinhole2D 
     22from .nxsunit import Converter 
    1823 
    1924def smear_selection(data, model = None): 
     
    3641    # Sanity check. If we are not dealing with a SAS Data1D 
    3742    # object, just return None 
     43    # This checks for 2D data (does not throw exception because fail is common) 
    3844    if  data.__class__.__name__ not in ['Data1D', 'Theory1D']: 
    3945        if data == None: 
     
    4147        elif data.dqx_data == None or data.dqy_data == None: 
    4248            return None 
    43         return PySmear2D(data, model) 
    44  
     49        return PySmear2D(data) 
     50    # This checks for 1D data with smearing info in the data itself (again, fail is likely; no exceptions) 
    4551    if  not hasattr(data, "dx") and not hasattr(data, "dxl")\ 
    4652         and not hasattr(data, "dxw"): 
     
    4854 
    4955    # 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 
    5078    _found_resolution = False 
    5179    if data.dx is not None and len(data.dx) == len(data.x): 
     
    89117    Wrapper for pure python sasmodels resolution functions. 
    90118    """ 
    91     def __init__(self, resolution, model): 
     119    def __init__(self, resolution, model, offset=None): 
    92120        self.model = model 
    93121        self.resolution = resolution 
    94         self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     122        if offset is None: 
     123            offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     124        self.offset = offset 
    95125 
    96126    def apply(self, iq_in, first_bin=0, last_bin=None): 
  • src/sas/sascalc/dataloader/data_info.py

    r345e7e4 r2ffe241  
    2525import numpy 
    2626import math 
    27  
    28 class 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  
    8027 
    8128class plottable_1D(object): 
     
    9340    ## Slit smearing width 
    9441    dxw = None 
     42    ## SESANS specific params (wavelengths for spin echo length calculation) 
     43    lam = None 
     44    dlam = None 
    9545 
    9646    # Units 
     
    10050    _yunit = '' 
    10151 
    102     def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None): 
     52    def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None, lam=None, dlam=None): 
    10353        self.x = numpy.asarray(x) 
    10454        self.y = numpy.asarray(y) 
     
    11161        if dxw is not None: 
    11262            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) 
    11367 
    11468    def xaxis(self, label, unit): 
     
    398352    ## Details 
    399353    details = None 
     354    ## SESANS zacceptance 
     355    zacceptance = None 
    400356 
    401357    def __init__(self): 
     
    535491    ## Loading errors 
    536492    errors = None 
     493    ## SESANS data check 
     494    isSesans = None 
     495 
    537496 
    538497    def __init__(self): 
     
    567526        ## Loading errors 
    568527        self.errors = [] 
     528        ## SESANS data check 
     529        self.isSesans = False 
    569530 
    570531    def append_empty_process(self): 
     
    586547        _str += "Title:           %s\n" % self.title 
    587548        _str += "Run:             %s\n" % str(self.run) 
     549        _str += "SESANS:          %s\n" % str(self.isSesans) 
    588550        _str += "Instrument:      %s\n" % str(self.instrument) 
    589551        _str += "%s\n" % str(self.sample) 
     
    736698        return self._perform_union(other) 
    737699 
    738 class 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): 
     700class 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): 
    746705        DataInfo.__init__(self) 
    747         plottable_sesans1D.__init__(self, x, y, lam, dx, dy, dlam) 
     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') 
    748717 
    749718    def __str__(self): 
     
    759728        return _str 
    760729 
    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  
    794 class 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  
    817730    def is_slit_smeared(self): 
    818731        """ 
     
    843756            y = numpy.zeros(length) 
    844757            dy = numpy.zeros(length) 
    845             clone = Data1D(x, y, dx=dx, dy=dy) 
     758            lam = numpy.zeros(length) 
     759            dlam = numpy.zeros(length) 
     760            clone = Data1D(x, y, lam=lam, dx=dx, dy=dy, dlam=dlam) 
    846761 
    847762        clone.title = self.title 
     
    1018933    ## Vector of Q-values at the center of each bin in y 
    1019934    y_bins = None 
     935    ## No 2D SESANS data as of yet. Always set it to False 
     936    isSesans = False 
    1020937 
    1021938    def __init__(self, data=None, err_data=None, qx_data=None, 
    1022939                 qy_data=None, q_data=None, mask=None, 
    1023940                 dqx_data=None, dqy_data=None): 
    1024         self.y_bins = [] 
    1025         self.x_bins = [] 
    1026941        DataInfo.__init__(self) 
    1027942        plottable_2D.__init__(self, data, err_data, qx_data, 
    1028943                              qy_data, q_data, mask, dqx_data, dqy_data) 
     944        self.y_bins = [] 
     945        self.x_bins = [] 
     946 
    1029947        if len(self.detector) > 0: 
    1030948            raise RuntimeError, "Data2D: Detector bank already filled at init" 
     
    12651183    final_dataset.xmin = data.xmin 
    12661184    final_dataset.ymin = data.ymin 
     1185    final_dataset.isSesans = datainfo.isSesans 
    12671186    final_dataset.title = datainfo.title 
    12681187    final_dataset.run = datainfo.run 
  • src/sas/sascalc/dataloader/readers/cansas_constants.py

    r250fec92 rad4632c  
    133133               "variable" : None, 
    134134               "children" : {"Idata" : SASDATA_IDATA, 
     135                             "Sesans": {"storeas": "content"}, 
     136                             "zacceptance": {"storeas": "float"}, 
    135137                             "<any>" : ANY 
    136138                            } 
  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    rbcabf4e r8434365  
    261261                # I and Q - 1D data 
    262262                elif tagname == 'I' and isinstance(self.current_dataset, plottable_1D): 
    263                     self.current_dataset.yaxis("Intensity", unit) 
     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) 
    264269                    self.current_dataset.y = np.append(self.current_dataset.y, data_point) 
    265270                elif tagname == 'Idev' and isinstance(self.current_dataset, plottable_1D): 
    266271                    self.current_dataset.dy = np.append(self.current_dataset.dy, data_point) 
    267272                elif tagname == 'Q': 
    268                     self.current_dataset.xaxis("Q", unit) 
     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) 
    269279                    self.current_dataset.x = np.append(self.current_dataset.x, data_point) 
    270280                elif tagname == 'Qdev': 
     
    278288                elif tagname == 'Shadowfactor': 
    279289                    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) 
    280294 
    281295                # I and Qx, Qy - 2D data 
     
    916930            self._write_data(datainfo, entry_node) 
    917931        # Transmission Spectrum Info 
    918         self._write_trans_spectrum(datainfo, entry_node) 
     932        # TODO: fix the writer to linearize all data, including T_spectrum 
     933        # self._write_trans_spectrum(datainfo, entry_node) 
    919934        # Sample info 
    920935        self._write_sample_info(datainfo, entry_node) 
     
    10201035            node.append(point) 
    10211036            self.write_node(point, "Q", datainfo.x[i], 
    1022                             {'unit': datainfo.x_unit}) 
     1037                            {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10231038            if len(datainfo.y) >= i: 
    10241039                self.write_node(point, "I", datainfo.y[i], 
    1025                                 {'unit': datainfo.y_unit}) 
     1040                                {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
    10261041            if datainfo.dy is not None and len(datainfo.dy) > i: 
    10271042                self.write_node(point, "Idev", datainfo.dy[i], 
    1028                                 {'unit': datainfo.y_unit}) 
     1043                                {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
    10291044            if datainfo.dx is not None and len(datainfo.dx) > i: 
    10301045                self.write_node(point, "Qdev", datainfo.dx[i], 
    1031                                 {'unit': datainfo.x_unit}) 
     1046                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10321047            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    10331048                self.write_node(point, "dQw", datainfo.dxw[i], 
    1034                                 {'unit': datainfo.x_unit}) 
     1049                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10351050            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    10361051                self.write_node(point, "dQl", datainfo.dxl[i], 
    1037                                 {'unit': datainfo.x_unit}) 
     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 
    10381060 
    10391061    def _write_data_2d(self, datainfo, entry_node): 
  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    rbbd0f37 rc94280c  
    99import sys 
    1010 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D, Data1D, Data2D, DataInfo, Process, Aperture 
    12 from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, Detector 
     11from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D,\ 
     12    Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \ 
     13    TransmissionSpectrum, Detector 
    1314from 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 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). 
     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). 
    2527 
    2628    Also supports reading NXcanSAS formatted HDF5 files 
     
    3032    """ 
    3133 
    32     ## CanSAS version 
     34    # CanSAS version 
    3335    cansas_version = 2.0 
    34     ## Logged warnings or messages 
     36    # Logged warnings or messages 
    3537    logging = None 
    36     ## List of errors for the current data set 
     38    # List of errors for the current data set 
    3739    errors = None 
    38     ## Raw file contents to be processed 
     40    # Raw file contents to be processed 
    3941    raw_data = None 
    40     ## Data info currently being read in 
     42    # Data info currently being read in 
    4143    current_datainfo = None 
    42     ## SASdata set currently being read in 
     44    # SASdata set currently being read in 
    4345    current_dataset = None 
    44     ## List of plottable1D objects that should be linked to the current_datainfo 
     46    # List of plottable1D objects that should be linked to the current_datainfo 
    4547    data1d = None 
    46     ## List of plottable2D objects that should be linked to the current_datainfo 
     48    # List of plottable2D objects that should be linked to the current_datainfo 
    4749    data2d = None 
    48     ## Data type name 
     50    # Data type name 
    4951    type_name = "CanSAS 2.0" 
    50     ## Wildcards 
     52    # Wildcards 
    5153    type = ["CanSAS 2.0 HDF5 Files (*.h5)|*.h5"] 
    52     ## List of allowed extensions 
     54    # List of allowed extensions 
    5355    ext = ['.h5', '.H5'] 
    54     ## Flag to bypass extension check 
    55     allow_all = False 
    56     ## List of files to return 
     56    # Flag to bypass extension check 
     57    allow_all = True 
     58    # List of files to return 
    5759    output = None 
    5860 
     
    6466        :return: List of Data1D/2D objects and/or a list of errors. 
    6567        """ 
    66         ## Reinitialize the class when loading a new data file to reset all class variables 
     68        # Reinitialize when loading a new data file to reset all class variables 
    6769        self.reset_class_variables() 
    68         ## Check that the file exists 
     70        # Check that the file exists 
    6971        if os.path.isfile(filename): 
    7072            basename = os.path.basename(filename) 
     
    7274            # If the file type is not allowed, return empty list 
    7375            if extension in self.ext or self.allow_all: 
    74                 ## Load the data file 
     76                # Load the data file 
    7577                self.raw_data = h5py.File(filename, 'r') 
    76                 ## Read in all child elements of top level SASroot 
     78                # Read in all child elements of top level SASroot 
    7779                self.read_children(self.raw_data, []) 
    78                 ## Add the last data set to the list of outputs 
     80                # Add the last data set to the list of outputs 
    7981                self.add_data_set() 
    80                 ## Close the data file 
     82                # Close the data file 
    8183                self.raw_data.close() 
    82         ## Return data set(s) 
     84        # Return data set(s) 
    8385        return self.output 
    8486 
     
    110112        """ 
    111113 
    112         ## Loop through each element of the parent and process accordingly 
     114        # Loop through each element of the parent and process accordingly 
    113115        for key in data.keys(): 
    114             ## Get all information for the current key 
     116            # Get all information for the current key 
    115117            value = data.get(key) 
    116118            if value.attrs.get(u'canSAS_class') is not None: 
     
    126128                self.parent_class = class_name 
    127129                parent_list.append(key) 
    128                 ## If this is a new sasentry, store the current data sets and create a fresh Data1D/2D object 
     130                # If a new sasentry, store the current data sets and create 
     131                # a fresh Data1D/2D object 
    129132                if class_prog.match(u'SASentry'): 
    130133                    self.add_data_set(key) 
    131134                elif class_prog.match(u'SASdata'): 
    132135                    self._initialize_new_data_set(parent_list) 
    133                 ## Recursion step to access data within the group 
     136                # Recursion step to access data within the group 
    134137                self.read_children(value, parent_list) 
    135138                self.add_intermediate() 
     
    137140 
    138141            elif isinstance(value, h5py.Dataset): 
    139                 ## If this is a dataset, store the data appropriately 
     142                # If this is a dataset, store the data appropriately 
    140143                data_set = data[key][:] 
    141144                unit = self._get_unit(value) 
    142145 
    143                 ## I and Q Data 
     146                # I and Q Data 
    144147                if key == u'I': 
    145                     if type(self.current_dataset) is plottable_2D: 
     148                    if isinstance(self.current_dataset, plottable_2D): 
    146149                        self.current_dataset.data = data_set 
    147150                        self.current_dataset.zaxis("Intensity", unit) 
     
    151154                    continue 
    152155                elif key == u'Idev': 
    153                     if type(self.current_dataset) is plottable_2D: 
     156                    if isinstance(self.current_dataset, plottable_2D): 
    154157                        self.current_dataset.err_data = data_set.flatten() 
    155158                    else: 
     
    158161                elif key == u'Q': 
    159162                    self.current_dataset.xaxis("Q", unit) 
    160                     if type(self.current_dataset) is plottable_2D: 
     163                    if isinstance(self.current_dataset, plottable_2D): 
    161164                        self.current_dataset.q = data_set.flatten() 
    162165                    else: 
     
    166169                    self.current_dataset.dx = data_set.flatten() 
    167170                    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 
    168177                elif key == u'Qy': 
    169178                    self.current_dataset.yaxis("Q_y", unit) 
     
    183192                    self.current_dataset.mask = data_set.flatten() 
    184193                    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 
    185208 
    186209                for data_point in data_set: 
    187                     ## Top Level Meta Data 
     210                    # Top Level Meta Data 
    188211                    if key == u'definition': 
    189212                        self.current_datainfo.meta_data['reader'] = data_point 
     
    201224                        self.current_datainfo.notes.append(data_point) 
    202225 
    203                     ## Sample Information 
    204                     elif key == u'Title' and self.parent_class == u'SASsample': # CanSAS 2.0 format 
     226                    # Sample Information 
     227                    # CanSAS 2.0 format 
     228                    elif key == u'Title' and self.parent_class == u'SASsample': 
    205229                        self.current_datainfo.sample.name = data_point 
    206                     elif key == u'ID' and self.parent_class == u'SASsample': # NXcanSAS format 
     230                    # NXcanSAS format 
     231                    elif key == u'name' and self.parent_class == u'SASsample': 
    207232                        self.current_datainfo.sample.name = data_point 
    208                     elif key == u'thickness' and self.parent_class == u'SASsample': 
     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'): 
    209238                        self.current_datainfo.sample.thickness = data_point 
    210                     elif key == u'temperature' and self.parent_class == u'SASsample': 
     239                    elif (key == u'temperature' 
     240                          and self.parent_class == u'SASsample'): 
    211241                        self.current_datainfo.sample.temperature = data_point 
    212                     elif key == u'transmission' and self.parent_class == u'SASsample': 
     242                    elif (key == u'transmission' 
     243                          and self.parent_class == u'SASsample'): 
    213244                        self.current_datainfo.sample.transmission = data_point 
    214                     elif key == u'x_position' and self.parent_class == u'SASsample': 
     245                    elif (key == u'x_position' 
     246                          and self.parent_class == u'SASsample'): 
    215247                        self.current_datainfo.sample.position.x = data_point 
    216                     elif key == u'y_position' and self.parent_class == u'SASsample': 
     248                    elif (key == u'y_position' 
     249                          and self.parent_class == u'SASsample'): 
    217250                        self.current_datainfo.sample.position.y = data_point 
    218                     elif key == u'polar_angle' and self.parent_class == u'SASsample': 
     251                    elif key == u'pitch' and self.parent_class == u'SASsample': 
    219252                        self.current_datainfo.sample.orientation.x = data_point 
    220                     elif key == u'azimuthal_angle' and self.parent_class == u'SASsample': 
     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': 
    221256                        self.current_datainfo.sample.orientation.z = data_point 
    222                     elif key == u'details' and self.parent_class == u'SASsample': 
     257                    elif (key == u'details' 
     258                          and self.parent_class == u'SASsample'): 
    223259                        self.current_datainfo.sample.details.append(data_point) 
    224260 
    225                     ## Instrumental Information 
    226                     elif key == u'name' and self.parent_class == u'SASinstrument': 
     261                    # Instrumental Information 
     262                    elif (key == u'name' 
     263                          and self.parent_class == u'SASinstrument'): 
    227264                        self.current_datainfo.instrument = data_point 
    228265                    elif key == u'name' and self.parent_class == u'SASdetector': 
     
    231268                        self.detector.distance = float(data_point) 
    232269                        self.detector.distance_unit = unit 
    233                     elif key == u'slit_length' and self.parent_class == u'SASdetector': 
     270                    elif (key == u'slit_length' 
     271                          and self.parent_class == u'SASdetector'): 
    234272                        self.detector.slit_length = float(data_point) 
    235273                        self.detector.slit_length_unit = unit 
    236                     elif key == u'x_position' and self.parent_class == u'SASdetector': 
     274                    elif (key == u'x_position' 
     275                          and self.parent_class == u'SASdetector'): 
    237276                        self.detector.offset.x = float(data_point) 
    238277                        self.detector.offset_unit = unit 
    239                     elif key == u'y_position' and self.parent_class == u'SASdetector': 
     278                    elif (key == u'y_position' 
     279                          and self.parent_class == u'SASdetector'): 
    240280                        self.detector.offset.y = float(data_point) 
    241281                        self.detector.offset_unit = unit 
    242                     elif key == u'polar_angle' and self.parent_class == u'SASdetector': 
     282                    elif (key == u'pitch' 
     283                          and self.parent_class == u'SASdetector'): 
    243284                        self.detector.orientation.x = float(data_point) 
    244285                        self.detector.orientation_unit = unit 
    245                     elif key == u'azimuthal_angle' and self.parent_class == u'SASdetector': 
     286                    elif key == u'roll' and self.parent_class == u'SASdetector': 
    246287                        self.detector.orientation.z = float(data_point) 
    247288                        self.detector.orientation_unit = unit 
    248                     elif key == u'beam_center_x' and self.parent_class == u'SASdetector': 
     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'): 
    249294                        self.detector.beam_center.x = float(data_point) 
    250295                        self.detector.beam_center_unit = unit 
    251                     elif key == u'beam_center_y' and self.parent_class == u'SASdetector': 
     296                    elif (key == u'beam_center_y' 
     297                          and self.parent_class == u'SASdetector'): 
    252298                        self.detector.beam_center.y = float(data_point) 
    253299                        self.detector.beam_center_unit = unit 
    254                     elif key == u'x_pixel_size' and self.parent_class == u'SASdetector': 
     300                    elif (key == u'x_pixel_size' 
     301                          and self.parent_class == u'SASdetector'): 
    255302                        self.detector.pixel_size.x = float(data_point) 
    256303                        self.detector.pixel_size_unit = unit 
    257                     elif key == u'y_pixel_size' and self.parent_class == u'SASdetector': 
     304                    elif (key == u'y_pixel_size' 
     305                          and self.parent_class == u'SASdetector'): 
    258306                        self.detector.pixel_size.y = float(data_point) 
    259307                        self.detector.pixel_size_unit = unit 
    260                     elif key == u'SSD' and self.parent_class == u'SAScollimation': 
     308                    elif (key == u'distance' 
     309                          and self.parent_class == u'SAScollimation'): 
    261310                        self.collimation.length = data_point 
    262311                        self.collimation.length_unit = unit 
    263                     elif key == u'name' and self.parent_class == u'SAScollimation': 
     312                    elif (key == u'name' 
     313                          and self.parent_class == u'SAScollimation'): 
    264314                        self.collimation.name = data_point 
    265  
    266                     ## Process Information 
    267                     elif key == u'name' and self.parent_class == u'SASprocess': 
     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 
    268328                        self.process.name = data_point 
    269                     elif key == u'Title' and self.parent_class == u'SASprocess': # CanSAS 2.0 format 
     329                    elif (key == u'name' 
     330                          and self.parent_class == u'SASprocess'): # NXcanSAS 
    270331                        self.process.name = data_point 
    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': 
     332                    elif (key == u'description' 
     333                          and self.parent_class == u'SASprocess'): 
    274334                        self.process.description = data_point 
    275335                    elif key == u'date' and self.parent_class == u'SASprocess': 
    276336                        self.process.date = data_point 
     337                    elif key == u'term' and self.parent_class == u'SASprocess': 
     338                        self.process.term = data_point 
    277339                    elif self.parent_class == u'SASprocess': 
    278340                        self.process.notes.append(data_point) 
    279341 
    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': 
     342                    # Source 
     343                    elif (key == u'wavelength' 
     344                          and self.parent_class == u'SASdata'): 
    290345                        self.current_datainfo.source.wavelength = data_point 
    291346                        self.current_datainfo.source.wavelength_unit = unit 
    292                     elif key == u'incident_wavelength' and self.parent_class == u'SASsource': 
     347                    elif (key == u'incident_wavelength' 
     348                          and self.parent_class == 'SASsource'): 
    293349                        self.current_datainfo.source.wavelength = data_point 
    294350                        self.current_datainfo.source.wavelength_unit = unit 
    295                     elif key == u'wavelength_max' and self.parent_class == u'SASsource': 
     351                    elif (key == u'wavelength_max' 
     352                          and self.parent_class == u'SASsource'): 
    296353                        self.current_datainfo.source.wavelength_max = data_point 
    297354                        self.current_datainfo.source.wavelength_max_unit = unit 
    298                     elif key == u'wavelength_min' and self.parent_class == u'SASsource': 
     355                    elif (key == u'wavelength_min' 
     356                          and self.parent_class == u'SASsource'): 
    299357                        self.current_datainfo.source.wavelength_min = data_point 
    300358                        self.current_datainfo.source.wavelength_min_unit = unit 
    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': 
     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'): 
    305367                        self.current_datainfo.source.beam_size.x = data_point 
    306368                        self.current_datainfo.source.beam_size_unit = unit 
    307                     elif key == u'beam_size_y' and self.parent_class == u'SASsource': 
     369                    elif (key == u'beam_size_y' 
     370                          and self.parent_class == u'SASsource'): 
    308371                        self.current_datainfo.source.beam_size.y = data_point 
    309372                        self.current_datainfo.source.beam_size_unit = unit 
    310                     elif key == u'beam_shape' and self.parent_class == u'SASsource': 
     373                    elif (key == u'beam_shape' 
     374                          and self.parent_class == u'SASsource'): 
    311375                        self.current_datainfo.source.beam_shape = data_point 
    312                     elif key == u'radiation' and self.parent_class == u'SASsource': 
     376                    elif (key == u'radiation' 
     377                          and self.parent_class == u'SASsource'): 
    313378                        self.current_datainfo.source.radiation = data_point 
    314                     elif key == u'transmission' and self.parent_class == u'SASdata': 
     379                    elif (key == u'transmission' 
     380                          and self.parent_class == u'SASdata'): 
    315381                        self.current_datainfo.sample.transmission = data_point 
    316382 
    317                     ## Everything else goes in meta_data 
     383                    # Everything else goes in meta_data 
    318384                    else: 
    319                         new_key = self._create_unique_key(self.current_datainfo.meta_data, key) 
     385                        new_key = self._create_unique_key( 
     386                            self.current_datainfo.meta_data, key) 
    320387                        self.current_datainfo.meta_data[new_key] = data_point 
    321388 
    322389            else: 
    323                 ## I don't know if this reachable code 
     390                # I don't know if this reachable code 
    324391                self.errors.add("ShouldNeverHappenException") 
    325392 
    326393    def add_intermediate(self): 
    327394        """ 
    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 
     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 
    331400        """ 
    332401 
     
    347416            self.aperture = Aperture() 
    348417        elif self.parent_class == u'SASdata': 
    349             if type(self.current_dataset) is plottable_2D: 
     418            if isinstance(self.current_dataset, plottable_2D): 
    350419                self.data2d.append(self.current_dataset) 
    351             elif type(self.current_dataset) is plottable_1D: 
     420            elif isinstance(self.current_dataset, plottable_1D): 
    352421                self.data1d.append(self.current_dataset) 
    353422 
    354423    def final_data_cleanup(self): 
    355424        """ 
    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 
     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 
    361431        if len(self.current_datainfo.trans_spectrum) > 0: 
    362432            spectrum_list = [] 
     
    364434                spectrum.transmission = np.delete(spectrum.transmission, [0]) 
    365435                spectrum.transmission = spectrum.transmission.astype(np.float64) 
    366                 spectrum.transmission_deviation = np.delete(spectrum.transmission_deviation, [0]) 
    367                 spectrum.transmission_deviation = spectrum.transmission_deviation.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) 
    368440                spectrum.wavelength = np.delete(spectrum.wavelength, [0]) 
    369441                spectrum.wavelength = spectrum.wavelength.astype(np.float64) 
     
    372444            self.current_datainfo.trans_spectrum = spectrum_list 
    373445 
    374         ## Append errors to dataset and reset class errors 
     446        # Append errors to dataset and reset class errors 
    375447        self.current_datainfo.errors = self.errors 
    376448        self.errors.clear() 
    377449 
    378         ## Combine all plottables with datainfo and append each to output 
    379         ## Type cast data arrays to float64 and find min/max as appropriate 
     450        # Combine all plottables with datainfo and append each to output 
     451        # Type cast data arrays to float64 and find min/max as appropriate 
    380452        for dataset in self.data2d: 
    381453            dataset.data = dataset.data.astype(np.float64) 
     
    397469            zeros = np.ones(dataset.data.size, dtype=bool) 
    398470            try: 
    399                 for i in range (0, dataset.mask.size - 1): 
     471                for i in range(0, dataset.mask.size - 1): 
    400472                    zeros[i] = dataset.mask[i] 
    401473            except: 
    402474                self.errors.add(sys.exc_value) 
    403475            dataset.mask = zeros 
    404             ## Calculate the actual Q matrix 
     476            # Calculate the actual Q matrix 
    405477            try: 
    406478                if dataset.q_data.size <= 1: 
    407                     dataset.q_data = np.sqrt(dataset.qx_data * dataset.qx_data + dataset.qy_data * dataset.qy_data) 
     479                    dataset.q_data = np.sqrt(dataset.qx_data 
     480                                             * dataset.qx_data 
     481                                             + dataset.qy_data 
     482                                             * dataset.qy_data) 
    408483            except: 
    409484                dataset.q_data = None 
     
    415490                dataset.data = dataset.data.flatten() 
    416491 
    417             final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo) 
     492            final_dataset = combine_data_info_with_plottable( 
     493                dataset, self.current_datainfo) 
    418494            self.output.append(final_dataset) 
    419495 
     
    435511            if dataset.dy is not None: 
    436512                dataset.dy = dataset.dy.astype(np.float64) 
    437             final_dataset = combine_data_info_with_plottable(dataset, self.current_datainfo) 
     513            final_dataset = combine_data_info_with_plottable( 
     514                dataset, self.current_datainfo) 
    438515            self.output.append(final_dataset) 
    439516 
    440517    def add_data_set(self, key=""): 
    441518        """ 
    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. 
     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. 
    444522 
    445523        :param key: NeXus group name for current tree level 
     
    453531 
    454532 
    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. 
     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. 
    459538 
    460539        :param parent_list: List of names of parent elements 
     
    473552    def _find_intermediate(self, parent_list, basename=""): 
    474553        """ 
    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 
     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 
    478558        :param basename: Approximate name of an entry to search for 
    479559        :return: 
     
    486566            top = top.get(parent) 
    487567        for key in top.keys(): 
    488             if (key_prog.match(key)): 
     568            if key_prog.match(key): 
    489569                entry = True 
    490570                break 
     
    516596        """ 
    517597        unit = value.attrs.get(u'units') 
    518         if unit == None: 
     598        if unit is None: 
    519599            unit = value.attrs.get(u'unit') 
    520         ## Convert the unit formats 
     600        # Convert the unit formats 
    521601        if unit == "1/A": 
    522602            unit = "A^{-1}" 
  • src/sas/sascalc/dataloader/readers/sesans_reader.py

    r345e7e4 r7caf3e5  
    88import numpy 
    99import os 
    10 from sas.sascalc.dataloader.data_info import SESANSData1D 
     10from sas.sascalc.dataloader.data_info import Data1D 
    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 
    6261                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                   
    7162                x  = numpy.zeros(0) 
    7263                y  = numpy.zeros(0) 
     
    8374                tdlam = numpy.zeros(0) 
    8475                tdx = numpy.zeros(0) 
    85 #                print "all good" 
    86                 output = SESANSData1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam) 
    87 #                print output                 
     76                output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True) 
    8877                self.filename = output.filename = basename 
    8978 
    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 
    10579                paramnames=[] 
    10680                paramvals=[] 
     
    11185                Pvals=[] 
    11286                dPvals=[] 
    113 #                print x 
    114 #                print zvals 
     87 
    11588                for line in lines: 
    11689                    # Initial try for CSV (split on ,) 
     
    12295                    if len(toks)>5: 
    12396                        zvals.append(toks[0]) 
    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]) 
     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]) 
    129102                    else: 
    130103                        continue 
     
    140113                default_z_unit = "A" 
    141114                data_conv_P = None 
    142                 default_p_unit = " " 
     115                default_p_unit = " " # Adjust unit for axis (L^-3) 
    143116                lam_unit = lam_header[1].replace("[","").replace("]","") 
     117                if lam_unit == 'AA': 
     118                    lam_unit = 'A' 
    144119                varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]] 
    145120                valrange=range(1, len(zvals)) 
     
    161136                output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit) 
    162137                output.y = y 
     138                output.y_unit = r'\AA^{-2} cm^{-1}'  # output y_unit added 
    163139                output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit) 
    164140                output.dy = dy 
    165141                output.lam, output.lam_unit = self._unit_conversion(lam, lam_unit, default_z_unit) 
    166142                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 
    167146 
    168                 output.xaxis("\rm{z}", output.x_unit) 
    169                 output.yaxis("\\rm{P/P0}", output.y_unit) 
    170147                # Store loading process information 
    171148                output.meta_data['loader'] = self.type_name 
    172                 output.sample.thickness = float(paramvals[6]) 
     149                #output.sample.thickness = float(paramvals[6]) 
    173150                output.sample.name = paramvals[1] 
    174151                output.sample.ID = paramvals[0] 
    175152                zaccept_unit_split = paramnames[7].split("[") 
    176153                zaccept_unit = zaccept_unit_split[1].replace("]","") 
    177                 if zaccept_unit.strip() == '\AA^-1': 
     154                if zaccept_unit.strip() == r'\AA^-1' or zaccept_unit.strip() == r'\A^-1': 
    178155                    zaccept_unit = "1/A" 
    179156                output.sample.zacceptance=(float(paramvals[7]),zaccept_unit) 
    180                 output.vars=varheader 
     157                output.vars = varheader 
    181158 
    182159                if len(output.x) < 1: 
  • src/sas/sascalc/fit/AbstractFitEngine.py

    rd3911e3 ra9f579c  
    131131        a way to get residuals from data. 
    132132    """ 
    133     def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None): 
     133    def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None, lam=None, dlam=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) 
     154        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy, lam=lam, dlam=dlam) 
    155155        self.num_points = len(x) 
    156156        self.sas_data = data 
  • src/sas/sascalc/fit/BumpsFitting.py

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

    r212bfc2 rddbac66  
    123123        compile it and install 
    124124        :param homefile: Override the default home directory 
    125         :param model_list: List of model names except customized models 
     125        :param model_list: List of model names except those in Plugin Models 
     126               which are user supplied. 
    126127        """ 
    127128        _model_dict = { model.name: model for model in model_list} 
  • src/sas/sasgui/guiframe/acknowledgebox.py

    rc1fdf84 r74c8cd0  
    1111import wx.richtext 
    1212import wx.lib.hyperlink 
     13from wx.lib.expando import ExpandoTextCtrl 
    1314import random 
    1415import os.path 
     
    3637    Shows the current method for acknowledging SasView in 
    3738    scholarly publications. 
    38  
    3939    """ 
    4040 
     
    4444        wx.Dialog.__init__(self, *args, **kwds) 
    4545 
    46         self.ack = wx.TextCtrl(self, style=wx.TE_LEFT|wx.TE_MULTILINE|wx.TE_BESTWRAP|wx.TE_READONLY|wx.TE_NO_VSCROLL) 
     46        self.ack = ExpandoTextCtrl(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)) 
     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) 
    4951        self.preamble = wx.StaticText(self, -1, config._acknowledgement_preamble) 
    5052        items = [config._acknowledgement_preamble_bullet1, 
     
    5254                 config._acknowledgement_preamble_bullet3, 
    5355                 config._acknowledgement_preamble_bullet4] 
    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]) 
     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]) 
    5860        self.static_line = wx.StaticLine(self, 0) 
    5961        self.__set_properties() 
     
    6971        self.SetTitle("Acknowledging SasView") 
    7072        #Increased size of box from (525, 225), SMK, 04/10/16 
    71         self.SetSize((600, 300)) 
     73        self.SetClientSize((600, 320)) 
    7274        # end wxGlade 
    7375 
     
    8183        sizer_titles.Add(self.preamble, 0, wx.ALL|wx.EXPAND, 5) 
    8284        sizer_titles.Add(self.list1, 0, wx.ALL|wx.EXPAND, 5) 
     85        sizer_titles.Add(self.ack, 0, wx.ALL|wx.EXPAND, 5) 
    8386        sizer_titles.Add(self.list2, 0, wx.ALL|wx.EXPAND, 5) 
     87        sizer_titles.Add(self.citation, 0, wx.ALL|wx.EXPAND, 5) 
    8488        sizer_titles.Add(self.list3, 0, wx.ALL|wx.EXPAND, 5) 
     89        #sizer_titles.Add(self.static_line, 0, wx.ALL|wx.EXPAND, 0) 
    8590        sizer_titles.Add(self.list4, 0, wx.ALL|wx.EXPAND, 5) 
    86         sizer_titles.Add(self.static_line, 0, wx.ALL|wx.EXPAND, 0) 
    87         sizer_titles.Add(self.ack, 0, wx.ALL|wx.EXPAND, 5) 
    8891        sizer_main.Add(sizer_titles, -1, wx.ALL|wx.EXPAND, 5) 
    8992        self.SetAutoLayout(True) 
     
    9194        self.Layout() 
    9295        self.Centre() 
     96        #self.SetClientSize(sizer_main.GetSize()) 
    9397        # end wxGlade 
    9498 
  • src/sas/sasgui/guiframe/config.py

    rd85c194 rf9d1f60  
    11""" 
    2 Application settings 
     2    Application settings 
    33""" 
     4import time 
    45import os 
    5 import time 
    66from sas.sasgui.guiframe.gui_style import GUIFRAME 
     7import sas.sasview 
     8import logging 
     9 
    710# Version of the application 
    8 __appname__ = "DummyView" 
    9 __version__ = '0.0.0' 
    10 __build__ = '1' 
     11__appname__ = "SasView" 
     12__version__ = sas.sasview.__version__ 
     13__build__ = sas.sasview.__build__ 
    1114__download_page__ = 'https://github.com/SasView/sasview/releases' 
    1215__update_URL__ = 'http://www.sasview.org/latestversion.json' 
    1316 
    14  
    1517# Debug message flag 
    16 __EVT_DEBUG__ = True 
     18__EVT_DEBUG__ = False 
    1719 
    1820# Flag for automated testing 
     
    2931_acknowledgement_preamble =\ 
    3032'''To ensure the long term support and development of this software please''' +\ 
    31 ''' remember to do the following.''' 
     33''' remember to:''' 
    3234_acknowledgement_preamble_bullet1 =\ 
    33 '''Acknowledge its use in your publications as suggested below''' 
     35'''Acknowledge its use in your publications as :''' 
    3436_acknowledgement_preamble_bullet2 =\ 
    35 '''Reference the following website: http://www.sasview.org''' 
     37'''Reference SasView as:''' 
    3638_acknowledgement_preamble_bullet3 =\ 
    3739'''Reference the model you used if appropriate (see documentation for refs)''' 
     
    3941'''Send us your reference for our records: developers@sasview.org''' 
    4042_acknowledgement_publications = \ 
    41 '''This work benefited from the use of the SasView application, originally 
    42 developed under NSF award DMR-0520547. 
     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''' 
     46 
     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 
    4349''' 
    44 _acknowledgement =  \ 
    45 '''This work originally developed as part of the DANSE project funded by the NSF 
    46 under grant DMR-0520547, and currently maintained by NIST, UMD, ORNL, ISIS, ESS 
    47 and ILL. 
    4850 
    49 ''' 
    5051_homepage = "http://www.sasview.org" 
    51 _download = "http://sourceforge.net/projects/sasview/files/" 
     52_download = __download_page__ 
    5253_authors = [] 
    5354_paper = "http://sourceforge.net/p/sasview/tickets/" 
    5455_license = "mailto:help@sasview.org" 
    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" 
     56 
     57 
     58icon_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "images")) 
     59logging.info("icon path: %s" % icon_path) 
     60media_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "media")) 
     61test_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") 
    6475_nist_url = "http://www.nist.gov/" 
    6576_umd_url = "http://www.umd.edu/" 
    6677_sns_url = "http://neutrons.ornl.gov/" 
     78_ornl_url = "http://neutrons.ornl.gov/" 
    6779_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" 
    7080_isis_url = "http://www.isis.stfc.ac.uk/" 
    7181_ess_url = "http://ess-scandinavia.eu/" 
    7282_ill_url = "http://www.ill.eu/" 
    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' 
    84 APPLICATION_WLIST = '' 
    85 APPLICATION_STATE_EXTENSION = None 
    86 PLUGINS_WLIST = [] 
    87 PLUGIN_STATE_EXTENSIONS = [] 
    88 SPLASH_SCREEN_PATH = "images/danse_logo.png" 
    89 DEFAULT_STYLE = GUIFRAME.SINGLE_APPLICATION 
    90 SPLASH_SCREEN_WIDTH = 500 
    91 SPLASH_SCREEN_HEIGHT = 300 
    92 WELCOME_PANEL_ON = False 
    93 TUTORIAL_PATH = None 
    94 SS_MAX_DISPLAY_TIME = 1500 
    95 PLOPANEL_WIDTH = 350 
    96 PLOPANEL_HEIGTH = 350 
    97 GUIFRAME_WIDTH = 1000 
    98 GUIFRAME_HEIGHT = 800 
    99 CONTROL_WIDTH = -1 
    100 CONTROL_HEIGHT = -1 
    101 SetupIconFile_win = os.path.join("images", "ball.ico") 
    102 SetupIconFile_mac = os.path.join("images", "ball.icns") 
    103 DefaultGroupName = "DANSE" 
    104 OutputBaseFilename = "setupGuiFrame" 
     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" 
     90marketplace_url = "http://marketplace.sasview.org/" 
     91 
     92#edit the list of file state your plugin can read 
     93APPLICATION_WLIST = 'SasView files (*.svs)|*.svs' 
     94APPLICATION_STATE_EXTENSION = '.svs' 
     95GUIFRAME_WIDTH = 1150 
     96GUIFRAME_HEIGHT = 840 
     97PLUGIN_STATE_EXTENSIONS = ['.fitv', '.inv', '.prv', '.crf'] 
     98PLUGINS_WLIST = ['Fitting files (*.fitv)|*.fitv', 
     99                 'Invariant files (*.inv)|*.inv', 
     100                 'P(r) files (*.prv)|*.prv', 
     101                 'Corfunc files (*.crf)|*.crf'] 
     102PLOPANEL_WIDTH = 415 
     103PLOPANEL_HEIGTH = 370 
    105104DATAPANEL_WIDTH = 235 
    106105DATAPANEL_HEIGHT = 700 
     106SPLASH_SCREEN_PATH = os.path.join(icon_path, "SVwelcome_mini.png") 
     107TUTORIAL_PATH = os.path.join(media_path, "Tutorial.pdf") 
     108DEFAULT_STYLE = GUIFRAME.MULTIPLE_APPLICATIONS|GUIFRAME.MANAGER_ON\ 
     109                    |GUIFRAME.CALCULATOR_ON|GUIFRAME.TOOLBAR_ON 
     110SPLASH_SCREEN_WIDTH = 512 
     111SPLASH_SCREEN_HEIGHT = 366 
     112SS_MAX_DISPLAY_TIME = 2000 
     113WELCOME_PANEL_ON = True 
     114WELCOME_PANEL_SHOW = False 
     115CLEANUP_PLOT = False 
     116# OPEN and SAVE project menu 
     117OPEN_SAVE_PROJECT_MENU = True 
     118#VIEW MENU 
     119VIEW_MENU = True 
     120#EDIT MENU 
     121EDIT_MENU = True 
     122 
     123SetupIconFile_win = os.path.join(icon_path, "ball.ico") 
     124SetupIconFile_mac = os.path.join(icon_path, "ball.icns") 
     125DefaultGroupName = "." 
     126OutputBaseFilename = "setupSasView" 
     127 
    107128FIXED_PANEL = True 
    108129DATALOADER_SHOW = True 
     
    113134# set a default perspective 
    114135DEFAULT_PERSPECTIVE = 'None' 
    115 # OPEN and SAVE project menu 
    116 OPEN_SAVE_PROJECT_MENU = True 
    117 CLEANUP_PLOT = False 
    118 # OPEN and SAVE project menu 
    119 OPEN_SAVE_PROJECT_MENU = False 
    120 #VIEW MENU 
    121 VIEW_MENU = False 
    122 #EDIT MENU 
    123 EDIT_MENU = False 
    124 import wx.lib.newevent 
    125 (StatusBarEvent, EVT_STATUS) = wx.lib.newevent.NewEvent() 
     136 
     137# Time out for updating sasview 
     138UPDATE_TIMEOUT = 2 
     139 
     140#OpenCL option 
     141SAS_OPENCL = None 
    126142 
    127143def printEVT(message): 
    128     """ 
    129     :TODO - need method documentation 
    130     """ 
    131144    if __EVT_DEBUG__: 
     145        """ 
     146        :TODO - Need method doc string 
     147        """ 
    132148        print "%g:  %s" % (time.clock(), message) 
    133      
     149 
    134150        if __EVT_DEBUG_2_FILE__: 
    135151            out = open(__EVT_DEBUG_FILENAME__, 'a') 
    136152            out.write("%10g:  %s\n" % (time.clock(), message)) 
    137153            out.close() 
    138              
  • src/sas/sasgui/guiframe/dataFitting.py

    r345e7e4 r68adf86  
    1717    """ 
    1818    """ 
    19     def __init__(self, x=None, y=None, dx=None, dy=None): 
     19 
     20    def __init__(self, x=None, y=None, dx=None, dy=None, lam=None, dlam=None, isSesans=False): 
    2021        """ 
    2122        """ 
     
    2425        if y is None: 
    2526            y = [] 
    26         PlotData1D.__init__(self, x, y, dx, dy) 
    27         LoadData1D.__init__(self, x, y, dx, dy) 
     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 
    2831        self.id = None 
    2932        self.list_group_id = [] 
     
    3235        self.path = None 
    3336        self.xtransform = None 
     37        if self.isSesans: 
     38            self.xtransform = "x" 
    3439        self.ytransform = None 
     40        if self.isSesans: 
     41            self.ytransform = "y" 
    3542        self.title = "" 
    3643        self.scale = None 
     
    6875        # First, check the data compatibility 
    6976        dy, dy_other = self._validity_check(other) 
    70         result = Data1D(x=[], y=[], dx=None, dy=None) 
     77        result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=None) 
    7178        result.clone_without_data(length=len(self.x), clone=self) 
    7279        result.copy_from_datainfo(data1d=self) 
     
    115122        # First, check the data compatibility 
    116123        self._validity_check_union(other) 
    117         result = Data1D(x=[], y=[], dx=None, dy=None) 
     124        result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=None) 
    118125        tot_length = len(self.x) + len(other.x) 
    119126        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) 
    120131        if self.dy == None or other.dy is None: 
    121132            result.dy = None 
     
    141152        result.y = numpy.append(self.y, other.y) 
    142153        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] 
    143159        if result.dy != None: 
    144160            result.dy = numpy.append(self.dy, other.dy) 
     
    260276        # First, check the data compatibility 
    261277        self._validity_check_union(other) 
    262         result = Data1D(x=[], y=[], dx=None, dy=None) 
     278        result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=[]) 
    263279        tot_length = len(self.x)+len(other.x) 
    264280        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) 
    265285        if self.dy == None or other.dy is None: 
    266286            result.dy = None 
     
    285305        result.y = numpy.append(self.y, other.y) 
    286306        result.y = result.y[ind] 
     307        result.lam = numpy.append(self.lam, other.lam) 
     308        result.lam = result.lam[ind] 
    287309        if result.dy != None: 
    288310            result.dy = numpy.append(self.dy, other.dy) 
  • src/sas/sasgui/guiframe/data_manager.py

    r345e7e4 r2ffe241  
    6161         
    6262        if issubclass(Data2D, data.__class__): 
    63             new_plot = Data2D(image=None, err_image=None)  
    64         else:  
    65             new_plot = Data1D(x=[], y=[], dx=None, dy=None) 
    66             
     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 
    6773        new_plot.copy_from_datainfo(data) 
    6874        data.clone_without_data(clone=new_plot) 
  • src/sas/sasgui/guiframe/data_panel.py

    rc8e1996 ra45a298  
    6666    IS_MAC = True 
    6767 
    68 STYLE_FLAG = wx.RAISED_BORDER | CT.TR_HAS_BUTTONS | CT.TR_HIDE_ROOT |\ 
    69                     wx.WANTS_CHARS | CT.TR_HAS_VARIABLE_ROW_HEIGHT 
     68STYLE_FLAG = (wx.RAISED_BORDER | CT.TR_HAS_BUTTONS | 
     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, *args, **kwds): 
     76    def __init__(self, parent, root, *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("Available Data") 
     99        self.root = self.AddRoot(root) 
    100100 
    101101    def OnCompareItems(self, item1, item2): 
     
    520520        Add a listcrtl in the panel 
    521521        """ 
    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) 
     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 
    525537        self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_CHECKING, self.on_check_item) 
    526538        self.tree_ctrl.Bind(CT.EVT_TREE_ITEM_MENU, self.on_right_click_data) 
     
    557569        wx.EVT_MENU(self, self.editmask_id, self.on_edit_data) 
    558570 
    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) 
     571        self.tree_ctrl_theory = DataTreeCtrl(parent=splitter, 
     572                                             style=wx.SUNKEN_BORDER, 
     573                                             root="Available Theory") 
    563574        self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_CHECKING, 
    564575                                   self.on_check_item) 
    565576        self.tree_ctrl_theory.Bind(CT.EVT_TREE_ITEM_MENU, 
    566577                                   self.on_right_click_theory) 
    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) 
     578        splitter.SplitHorizontally(self.tree_ctrl, self.tree_ctrl_theory) 
     579        self.sizer1.Add(splitter, 1, wx.EXPAND | wx.ALL, 10) 
    571580 
    572581    def on_right_click_theory(self, event): 
     
    722731            if self.tree_ctrl.root: 
    723732                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() 
    724736        self.enable_remove() 
    725737        self.enable_import() 
     
    760772                                       state_id=state_id, 
    761773                                       theory_list=theory_list) 
     774        if self.tree_ctrl_theory.GetCount() > 0: 
     775            self.tree_ctrl_theory.root.Expand() 
    762776 
    763777    def append_theory_helper(self, tree, root, state_id, theory_list): 
  • src/sas/sasgui/perspectives/calculator/model_editor.py

    ra08b89b rddbac66  
    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 customizatin is provided. 
    8  
    9 :TODO the writiong of the file and name checking (and maybe some other 
    10 funtions?) should be moved to a computational module which could be called 
    11 fropm a python script.  Basically one just needs to pass the name, 
     7complete customization is provided. 
     8 
     9:TODO the writing of the file and name checking (and maybe some other 
     10functions?) should be moved to a computational module which could be called 
     11from 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 custom models which 
     63    to choose two existing models (including pre-existing Plugin 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 Custom Sum/Multipy: Error occurred..." 
     382            msg = "Easy Sum/Multipy Plugin: Error occurred..." 
    383383            info = 'Error' 
    384384            color = 'red' 
     
    501501        self.factor = factor 
    502502        self._operator = operator 
    503         self.explanation = "  Custom Model = %s %s (model1 %s model2)\n" % \ 
     503        self.explanation = "  Plugin 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     Custom model function editor 
     619    Simple Plugin Model function editor 
    620620    """ 
    621621    def __init__(self, parent, base, path, title, *args, **kwds): 
     
    652652        self.msg_sizer = None 
    653653        self.warning = "" 
    654         self._description = "New Custom Model" 
     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" 
    655657        self.function_tcl = None 
    656658        self.math_combo = None 
     
    991993        else: 
    992994            self._notes = result 
    993             msg = "Successful! Please look for %s in Customized Models."%name 
     995            msg = "Successful! Please look for %s in Plugin Models."%name 
    994996            msg += "  " + self._notes 
    995997            info = 'Info' 
     
    11381140    def on_help(self, event): 
    11391141        """ 
    1140         Bring up the Custom Model Editor Documentation whenever 
     1142        Bring up the New Plugin Model Editor Documentation whenever 
    11411143        the HELP button is clicked. 
    11421144 
     
    11901192        #self.Destroy() 
    11911193 
    1192 ## Templates for custom models 
     1194## Templates for plugin models 
    11931195 
    11941196CUSTOM_TEMPLATE = """ 
  • src/sas/sasgui/perspectives/calculator/pyconsole.py

    rd472e86 rddbac66  
    302302        success = show_model_output(self, fname) 
    303303 
    304         # Update custom model list in fitpage combobox 
     304        # Update plugin 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

    r1a8e13f0 r5156918  
    5353    ON_MAC = True 
    5454 
     55CUSTOM_MODEL = 'Plugin Models' 
     56 
    5557class BasicPage(ScrolledPanel, PanelBase): 
    5658    """ 
    57     This class provide general structure of fitpanel page 
     59    This class provide general structure of the fitpanel page 
    5860    """ 
    5961    # Internal name for the AUI manager 
     
    118120        self.dxw = None 
    119121        # pinhole smear 
    120         self.dx_min = None 
    121         self.dx_max = None 
     122        self.dx_percent = None 
    122123        # smear attrbs 
    123124        self.enable_smearer = None 
     
    677678    def _copy_info(self, flag): 
    678679        """ 
    679         Send event dpemding on flag 
    680  
    681         : Param flag: flag that distinguish event 
     680        Send event depending on flag 
     681 
     682        : Param flag: flag that distinguishes the event 
    682683        """ 
    683684        # messages depending on the flag 
     
    847848        self.state.pinhole_smearer = \ 
    848849                                copy.deepcopy(self.pinhole_smearer.GetValue()) 
    849         self.state.dx_max = copy.deepcopy(self.dx_max) 
    850         self.state.dx_min = copy.deepcopy(self.dx_min) 
     850        self.state.dx_percent = copy.deepcopy(self.dx_percent) 
    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 change as well as the 
     1121        :postcondition: the state of the underlying data changes 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() == 'Customized Models' \ 
     1169        if self.categorybox.GetValue() == CUSTOM_MODEL \ 
    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_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)) 
     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) 
    12531252            self.onPinholeSmear(event=None) 
    12541253        elif self.slit_smearer.GetValue(): 
     
    13351334    def _selectDlg(self): 
    13361335        """ 
    1337         open a dialog file to selected the customized dispersity 
     1336        open a dialog file to select the customized polydispersity function 
    13381337        """ 
    13391338        if self.parent is not None: 
     
    17471746    def _set_multfactor_combobox(self, multiplicity=10): 
    17481747        """ 
    1749         Set comboBox for muitfactor of CoreMultiShellModel 
     1748        Set comboBox for multitfactor of CoreMultiShellModel 
    17501749        :param multiplicit: no. of multi-functionality 
    17511750        """ 
     
    17851784        Fill panel's combo box according to the type of model selected 
    17861785        """ 
    1787         custom_model = 'Customized Models' 
     1786 
    17881787        mod_cat = self.categorybox.GetStringSelection() 
    17891788        self.structurebox.SetSelection(0) 
     
    17941793        m_list = [] 
    17951794        try: 
    1796             if mod_cat == custom_model: 
     1795            if mod_cat == CUSTOM_MODEL: 
    17971796                for model in self.model_list_box[mod_cat]: 
    17981797                    m_list.append(self.model_dict[model.name]) 
     
    34303429        fills out the category list box 
    34313430        """ 
    3432         uncat_str = 'Customized Models' 
     3431        uncat_str = 'Plugin Models' 
    34333432        self._read_category_info() 
    34343433 
     
    34593458        self.model_box.Clear() 
    34603459 
    3461         if category == 'Customized Models': 
     3460        if category == 'Plugin Models': 
    34623461            for model in self.model_list_box[category]: 
    34633462                str_m = str(model).split(".")[0] 
  • src/sas/sasgui/perspectives/fitting/fitpage.py

    r1a8e13f0 r5156918  
    2929_BOX_WIDTH = 76 
    3030_DATA_BOX_WIDTH = 300 
    31 SMEAR_SIZE_L = 0.00 
    3231SMEAR_SIZE_H = 0.00 
    33  
     32CUSTOM_MODEL = 'Plugin Models' 
    3433 
    3534class FitPage(BasicPage): 
     
    164163        On_select_data 
    165164        """ 
    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() 
     165        if self.dataSource.GetCount() > 0: 
     166            pos = self.dataSource.GetSelection() if event is not None else 0 
    171167            data = self.dataSource.GetClientData(pos) 
    172168            self.set_data(data) 
     
    213209              "Please enter only the value of interest to customize smearing..." 
    214210        smear_message_new_psmear = \ 
    215               "Please enter both; the dQ will be generated by interpolation..." 
     211              "Please enter a fixed percentage to be applied to all Q values..." 
    216212        smear_message_2d_x_title = "<dQp>[1/A]:" 
    217213        smear_message_2d_y_title = "<dQs>[1/A]:" 
    218         smear_message_pinhole_min_title = "dQ_low[1/A]:" 
    219         smear_message_pinhole_max_title = "dQ_high[1/A]:" 
     214        smear_message_pinhole_percent_title = "dQ[%]:" 
    220215        smear_message_slit_height_title = "Slit height[1/A]:" 
    221216        smear_message_slit_width_title = "Slit width[1/A]:" 
     
    256251        self.Bind(wx.EVT_RADIOBUTTON, self.onWeighting, 
    257252                  id=self.dI_idata.GetId()) 
    258         self.dI_didata.SetValue(True) 
     253        self.dI_noweight.SetValue(True) 
    259254        # add 4 types of weighting to the sizer 
    260255        sizer_weighting.Add(self.dI_noweight, 0, wx.LEFT, 10) 
     
    266261        sizer_weighting.Add(self.dI_idata) 
    267262        sizer_weighting.Add((10, 10)) 
    268         self.dI_noweight.Enable(False) 
     263        self.dI_noweight.Enable(True) 
    269264        self.dI_didata.Enable(False) 
    270265        self.dI_sqrdata.Enable(False) 
     
    310305         
    311306        # textcntrl for custom resolution 
    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) 
     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) 
    320312        self.smear_slit_height = ModelTextCtrl(self, wx.ID_ANY, 
    321313                            size=(_BOX_WIDTH - 25, 20), 
     
    336328 
    337329        # set default values for smear 
    338         self.smear_pinhole_max.SetValue(str(self.dx_max)) 
    339         self.smear_pinhole_min.SetValue(str(self.dx_min)) 
     330        self.smear_pinhole_percent.SetValue(str(self.dx_percent)) 
    340331        self.smear_slit_height.SetValue(str(self.dxl)) 
    341332        self.smear_slit_width.SetValue(str(self.dxw)) 
     
    362353        self.Bind(wx.EVT_RADIOBUTTON, self.onSlitSmear, 
    363354                  id=self.slit_smearer.GetId()) 
    364         self.enable_smearer.SetValue(True) 
     355        self.disable_smearer.SetValue(True) 
    365356 
    366357        sizer_smearer.Add(self.disable_smearer, 0, wx.LEFT, 10) 
     
    429420        self.smear_description_2d_y.SetToolTipString( 
    430421                                    " dQs(perpendicular) in q_phi direction.") 
    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) 
     422        self.smear_description_pin_percent = wx.StaticText(self, wx.ID_ANY, 
     423                                            smear_message_pinhole_percent_title, 
     424                                            style=wx.ALIGN_LEFT) 
    435425        self.smear_description_slit_height = wx.StaticText(self, wx.ID_ANY, 
    436426                        smear_message_slit_height_title, style=wx.ALIGN_LEFT) 
     
    456446        self.sizer_new_smear.Add((15, -1)) 
    457447        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) 
    460448        self.sizer_new_smear.Add(self.smear_description_slit_height, 
    461449                                 0, wx.CENTER, 10) 
    462450 
    463         self.sizer_new_smear.Add(self.smear_pinhole_min, 0, wx.CENTER, 10) 
    464451        self.sizer_new_smear.Add(self.smear_slit_height, 0, wx.CENTER, 10) 
    465452        self.sizer_new_smear.Add(self.smear_data_left, 0, wx.CENTER, 10) 
     
    467454        self.sizer_new_smear.Add(self.smear_description_2d_y, 
    468455                                 0, wx.CENTER, 10) 
    469         self.sizer_new_smear.Add(self.smear_description_pin_max, 
     456        self.sizer_new_smear.Add(self.smear_description_pin_percent, 
    470457                                 0, wx.CENTER, 10) 
    471458        self.sizer_new_smear.Add(self.smear_description_slit_width, 
    472459                                 0, wx.CENTER, 10) 
    473460 
    474         self.sizer_new_smear.Add(self.smear_pinhole_max, 0, wx.CENTER, 10) 
     461        self.sizer_new_smear.Add(self.smear_pinhole_percent, 0, wx.CENTER, 10) 
    475462        self.sizer_new_smear.Add(self.smear_slit_width, 0, wx.CENTER, 10) 
    476463        self.sizer_new_smear.Add(self.smear_data_right, 0, wx.CENTER, 10) 
     
    12491236            wx.PostEvent(self.parent, new_event) 
    12501237            # update list of plugins if new plugin is available 
    1251             custom_model = 'Customized Models' 
     1238            custom_model = CUSTOM_MODEL 
    12521239            mod_cat = self.categorybox.GetStringSelection() 
    12531240            if mod_cat == custom_model: 
     
    12711258            if copy_flag: 
    12721259                self.get_paste_params(copy_flag) 
    1273                 wx.CallAfter(self._onDraw, None) 
     1260            wx.CallAfter(self._onDraw, None) 
    12741261 
    12751262        else: 
     
    15841571        if self.dxw is None: 
    15851572            self.dxw = "" 
    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 
     1573        if self.dx_percent is None: 
     1574            self.dx_percent = SMEAR_SIZE_H 
    15901575 
    15911576    def _get_smear_info(self): 
     
    16271612        elif data.dxl is not None or data.dxw is not None: 
    16281613            self.smear_type = "Slit" 
    1629             if data.dxl is not None and not numpy.all(data.dxl, 0): 
     1614            if data.dxl is not None and numpy.all(data.dxl, 0): 
    16301615                self.dq_l = data.dxl[0] 
    1631             if data.dxw is not None and not numpy.all(data.dxw, 0): 
     1616            if data.dxw is not None and numpy.all(data.dxw, 0): 
    16321617                self.dq_r = data.dxw[0] 
    16331618        # return self.smear_type,self.dq_l,self.dq_r 
     
    16491634            self.smear_description_2d_y.Show(True) 
    16501635            if self.pinhole_smearer.GetValue(): 
    1651                 self.smear_pinhole_min.Show(True) 
    1652                 self.smear_pinhole_max.Show(True) 
     1636                self.smear_pinhole_percent.Show(True) 
    16531637        # smear from data 
    16541638        elif self.enable_smearer.GetValue(): 
     
    16611645                    self.smear_description_slit_width.Show(True) 
    16621646                elif self.smear_type == 'Pinhole': 
    1663                     self.smear_description_pin_min.Show(True) 
    1664                     self.smear_description_pin_max.Show(True) 
     1647                    self.smear_description_pin_percent.Show(True) 
    16651648                self.smear_description_smear_type.Show(True) 
    16661649                self.smear_description_type.Show(True) 
     
    16711654            if self.smear_type == 'Pinhole': 
    16721655                self.smear_message_new_p.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) 
     1656                self.smear_description_pin_percent.Show(True) 
     1657 
     1658            self.smear_pinhole_percent.Show(True) 
    16781659        # custom slit smear 
    16791660        elif self.slit_smearer.GetValue(): 
     
    17001681        self.smear_data_left.Hide() 
    17011682        self.smear_data_right.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() 
     1683        self.smear_description_pin_percent.Hide() 
     1684        self.smear_pinhole_percent.Hide() 
    17061685        self.smear_description_slit_height.Hide() 
    17071686        self.smear_slit_height.Hide() 
     
    19271906 
    19281907            # more disables for 2D 
     1908            di_flag = False 
     1909            dq_flag = False 
    19291910            if self.data.__class__.__name__ == "Data2D" or \ 
    19301911                        self.enable2D: 
     
    19321913                self.pinhole_smearer.Enable(True) 
    19331914                self.default_mask = copy.deepcopy(self.data.mask) 
    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() 
     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 
    19441921            else: 
    19451922                self.slit_smearer.Enable(True) 
    19461923                self.pinhole_smearer.Enable(True) 
    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() 
     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 
    19581949            # Enable weighting radio buttons 
    19591950            self.dI_noweight.Enable(True) 
     
    19971988            self.EditMask_title.Disable() 
    19981989 
     1990        self.on_smear_helper() 
    19991991        self.on_set_focus(None) 
    20001992        self.Refresh() 
     
    22282220            # event case of radio button 
    22292221            if tcrtl.GetValue(): 
    2230                 self.dx_min = 0.0 
    2231                 self.dx_max = 0.0 
     2222                self.dx_percent = 0.0 
    22322223                is_new_pinhole = True 
    22332224            else: 
     
    22662257        """ 
    22672258        # get the values 
    2268         pin_min = self.smear_pinhole_min.GetValue() 
    2269         pin_max = self.smear_pinhole_max.GetValue() 
    2270  
    2271         # Check changes in slit width 
     2259        pin_percent = self.smear_pinhole_percent.GetValue() 
     2260 
     2261        # Check changes in slit heigth 
    22722262        try: 
    2273             dx_min = float(pin_min) 
     2263            dx_percent = float(pin_percent) 
    22742264        except: 
    22752265            return True 
    2276         if self.dx_min != dx_min: 
    2277             return True 
    2278  
    2279         # Check changes in slit heigth 
    2280         try: 
    2281             dx_max = float(pin_max) 
    2282         except: 
    2283             return True 
    2284         if self.dx_max != dx_max: 
     2266        if self.dx_percent != dx_percent: 
    22852267            return True 
    22862268        return False 
     
    23082290        msg = None 
    23092291 
    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") 
     2292        get_pin_percent = self.smear_pinhole_percent 
     2293 
     2294        if not check_float(get_pin_percent): 
     2295            get_pin_percent.SetBackgroundColour("pink") 
    23182296            msg = "Model Error:wrong value entered!!!" 
    23192297        else: 
    23202298            if len_data < 2: 
    23212299                len_data = 2 
    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") 
     2300            self.dx_percent = float(get_pin_percent.GetValue()) 
     2301            if self.dx_percent < 0: 
     2302                get_pin_percent.SetBackgroundColour("pink") 
    23262303                msg = "Model Error:This value can not be negative!!!" 
    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: 
     2304            elif self.dx_percent is not None: 
     2305                percent = self.dx_percent/100 
    23312306                if self._is_2D(): 
    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 
     2307                    data.dqx_data[data.dqx_data == 0] = percent * data.qx_data 
     2308                    data.dqy_data[data.dqy_data == 0] = percent * data.qy_data 
    23362309                else: 
    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 
     2310                    data.dx = percent * data.x 
    23512311            self.current_smearer = smear_selection(data, self.model) 
    23522312            # 2D need to set accuracy 
     
    23582318            wx.PostEvent(self._manager.parent, StatusEvent(status=msg)) 
    23592319        else: 
    2360             get_pin_min.SetBackgroundColour("white") 
    2361             get_pin_max.SetBackgroundColour("white") 
     2320            get_pin_percent.SetBackgroundColour("white") 
    23622321        # set smearing value whether or not the data contain the smearing info 
    23632322 
  • src/sas/sasgui/perspectives/fitting/fitting.py

    r1a8e13f0 r5156918  
    225225 
    226226        self.id_edit = wx.NewId() 
    227         editmodel_help = "Edit customized model sample file" 
    228227        self.menu1.AppendMenu(self.id_edit, "Plugin Model Operations", 
    229                               self.edit_model_menu, editmodel_help) 
     228                              self.edit_model_menu) 
    230229        #create  menubar items 
    231230        return [(self.menu1, self.sub_menu)] 
     
    260259            self.update_custom_combo() 
    261260            if os.path.isfile(p_path): 
    262                 msg = "Sorry! Could not be able to delete the default " 
    263                 msg += "custom model... \n" 
     261                msg = "Sorry! unable to delete the default " 
     262                msg += "plugin model... \n" 
    264263                msg += "Please manually remove the files (.py, .pyc) " 
    265264                msg += "in the 'plugin_models' folder \n" 
     
    274273                    if item.GetLabel() == label: 
    275274                        self.edit_menu.DeleteItem(item) 
    276                         msg = "The custom model, %s, has been deleted." % label 
     275                        msg = "The plugin model, %s, has been deleted." % label 
    277276                        evt = StatusEvent(status=msg, type='stop', info='info') 
    278277                        wx.PostEvent(self.parent, evt) 
     
    331330            temp = self.fit_panel.reset_pmodel_list() 
    332331            if temp: 
    333                 # Set the new custom model list for all fit pages 
     332                # Set the new plugin model list for all fit pages 
    334333                for uid, page in self.fit_panel.opened_pages.iteritems(): 
    335334                    if hasattr(page, "formfactorbox"): 
     
    17461745                                          data_id="Data  " + data.name + " unsmeared", 
    17471746                                          dy=unsmeared_error) 
    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  
     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)") 
    17571755 
    17581756            current_pg = self.fit_panel.get_page_by_id(page_id) 
     
    19551953                ## then kill itself but cannot.  Paul Kienzle came up with 
    19561954                ## this fix to prevent threads from stepping on each other 
    1957                 ## which was causing a simple custom model to crash Sasview. 
     1955                ## which was causing a simple custom plugin model to crash 
     1956                ##Sasview. 
    19581957                ## We still don't know why the fit sometimes lauched a second 
    19591958                ## thread -- something which should also be investigated. 
  • src/sas/sasgui/perspectives/fitting/media/fitting_help.rst

    r26c8be3 r5295cf5  
    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 the *same* model with/without constrained parameters (this might be useful, for example, if you have measured the same sample at different contrasts) 
     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) 
    3739 
    3840*  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!) 
     
    4345----------------- 
    4446 
    45 By default, the models in SasView are grouped into five categories 
    46  
    47 *  *Shapes* - models describing 'objects' (spheres, cylinders, etc) 
     47The 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) 
    4856*  *Shape-Independent* - models describing structure in terms of density correlation functions, fractals, peaks, power laws, etc 
    49 *  *Customized Models* - SasView- or User-created (non-library) Python models 
    50 *  *Uncategorised* - other models (for reflectivity, etc) 
     57*  *Paracrystal* - semi ordered structures (bcc, fcc, etc) 
    5158*  *Structure Factor* - S(Q) models 
     59*  *Plugin Models* - User-created (custom/non-library) Python models 
    5260 
    5361Use the *Category* drop-down menu to chose a category of model, then select 
     
    8492.. image:: cat_fig0.bmp 
    8593 
    86 The categorization of all models except the customized models can be reassigned, 
    87 added to, and removed using *Category Manager*. Models can also be hidden from view 
    88 in the drop-down menus. 
     94The categorization of all models except the user supplied Plugin Models can be 
     95reassigned, added to, and removed using *Category Manager*. Models can also be 
     96hidden from view in the drop-down menus. 
    8997 
    9098.. image:: cat_fig1.bmp 
     
    93101^^^^^^^^^^^^^^^^^ 
    94102 
    95 To change category, highlight a model in the list by left-clicking on its entry and 
    96 then click the *Modify* button. Use the *Change Category* panel that appears to make 
    97 the required changes. 
     103To change category, highlight a model in the list by left-clicking on its entry 
     104and then click the *Modify* button. Use the *Change Category* panel that appears 
     105to make the required changes. 
    98106 
    99107.. image:: cat_fig2.bmp 
     
    106114^^^^^^^^^^^^^^^^^^^^^ 
    107115 
    108 Use the *Enable All / Disable All* buttons and the check boxes beside each model to 
    109 select the models to show/hide. To apply the selection, click *Ok*. Otherwise click 
    110 *Cancel*. 
     116Use the *Enable All / Disable All* buttons and the check boxes beside each model 
     117to select the models to show/hide. To apply the selection, click *Ok*. Otherwise 
     118click *Cancel*. 
    111119 
    112120*NB: It may be necessary to change to a different category and then back again* 
     
    118126--------------- 
    119127 
    120 For a complete list of all the library models available in SasView, see the `Model Documentation <../../../index.html>`_ . 
     128For a complete list of all the library models available in SasView, see 
     129the `Model Documentation <../../../index.html>`_ . 
    121130 
    122131It is also possible to add your own models. 
     
    131140There are essentially three ways to generate new fitting models for SasView: 
    132141 
    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!) 
     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!) 
    136149 
    137150Please read the guidance on :ref:`Writing_a_Plugin` before proceeding. 
     
    163176^^^^^^^^^^^^^^^^ 
    164177 
    165 Relatively straightforward models can be programmed directly from the SasView GUI  
    166 using the *New Plugin Model Function*. 
     178Relatively straightforward models can be programmed directly from the SasView 
     179GUI using the *New Plugin Model Function*. 
    167180 
    168181.. image:: new_model.bmp 
     
    175188*checked*\ . 
    176189 
    177 Also note that the 'Fit Parameters' have been split into two sections: those which  
    178 can be polydisperse (shape and orientation parameters) and those which are not 
    179 (eg, scattering length densities). 
     190Also note that the 'Fit Parameters' have been split into two sections: those 
     191which can be polydisperse (shape and orientation parameters) and those which are 
     192not (eg, scattering length densities). 
    180193 
    181194A model file generated by this option can be viewed and further modified using 
     
    187200.. image:: sum_model.bmp 
    188201 
    189 This option creates a custom model of the form:: 
    190  
    191      Custom Model = scale_factor \* {(scale_1 \* model_1) \+ (scale_2 \* model_2)} \+ background 
     202This option creates a custom Plugin Model of the form:: 
     203 
     204     Plugin Model = scale_factor * {(scale_1 * model_1) +/- (scale_2 * model_2)} + background 
    192205 
    193206or:: 
    194207 
    195      Custom Model = scale_factor \* model_1 \* model_2 \+ background 
     208     Plugin Model = scale_factor * model_1 /* model_2 + background 
    196209 
    197210In the *Easy Sum/Multi Editor* give the new model a function name and brief 
     
    232245Simply highlight the plugin model to be removed. The operation is final!!! 
    233246 
    234 *NB: Plugin models shipped with SasView cannot be removed in this way.* 
     247*NB: Models shipped with SasView cannot be removed in this way.* 
    235248 
    236249Load Plugin Models 
    237250^^^^^^^^^^^^^^^^^^ 
    238251 
    239 This option loads (or re-loads) all models present in the *~\\.sasview\\plugin_models* folder. 
     252This option loads (or re-loads) all models present in the 
     253*~\\.sasview\\plugin_models* folder. 
    240254 
    241255.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 
     
    400414:ref:`Assessing_Fit_Quality`. 
    401415 
    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` *).* 
     416*NB: If you need to use a custom Plugin Model, you must ensure that model is 
     417available first (see* :ref:`Adding_your_own_models` *).* 
    404418 
    405419Method 
     
    484498If multiple data sets are in one file, load just that file. *Unselect All Data*, then 
    485499select a single initial data set to be fitted. Fit that selected data set as described 
    486 above 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` *).* 
     500above under :ref:`Single_Fit_Mode`. 
     501 
     502*NB: If you need to use a custom Plugin Model, you must ensure that model is 
     503available first (see* :ref:`Adding_your_own_models` *).* 
    490504 
    491505Method 
  • src/sas/sasgui/perspectives/fitting/media/plugin.rst

    rca6cbc1c r984f3fc  
    2727 
    2828the next time SasView is started it will compile the plugin and add 
    29 it to the list of *Customized Models* in a FitPage. 
     29it to the list of *Plugin 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. 
    366369 
    367370- **"type"** can be one of: "", "sld", "volume", or "orientation". 
  • src/sas/sasgui/perspectives/fitting/model_thread.py

    rc1681ea rc1c9929  
    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 
    179180            output = self.smearer(unsmeared_output, first_bin, last_bin) 
    180181 
  • src/sas/sasgui/perspectives/fitting/models.py

    r0de74af r11b094f  
    325325                    self.plugins.append(plug) 
    326326                    self.model_dictionary[name] = plug 
    327             self.model_combobox.set_list("Customized Models", self.plugins) 
     327            self.model_combobox.set_list("Plugin 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("Customized Models", self.plugins) 
     348        self.model_combobox.reset_list("Plugin 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("Customized Models", self.plugins) 
     391        self.model_combobox.set_list("Plugin 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

    r6d2b50b r27109e5  
    3333from sas.sascalc.dataloader.data_info import Data2D, Collimation, Detector 
    3434from sas.sascalc.dataloader.data_info import Process, Aperture 
     35 
    3536# Information to read/write state as xml 
    3637FITTING_NODE_NAME = 'fitting_plug_in' 
    3738CANSAS_NS = "cansas1d/1.0" 
     39 
     40CUSTOM_MODEL = 'Plugin Models' 
     41CUSTOM_MODEL_OLD = 'Customized Models' 
    3842 
    3943LIST_OF_DATA_ATTRIBUTES = [["is_data", "is_data", "bool"], 
     
    7074                            ["dq_l", "dq_l", "float"], 
    7175                            ["dq_r", "dq_r", "float"], 
    72                             ["dx_max", "dx_max", "float"], 
    73                             ["dx_min", "dx_min", "float"], 
     76                            ["dx_percent", "dx_percent", "float"], 
    7477                            ["dxl", "dxl", "float"], 
    7578                            ["dxw", "dxw", "float"]] 
     
    211214        self.dq_l = None 
    212215        self.dq_r = None 
    213         self.dx_max = None 
    214         self.dx_min = None 
     216        self.dx_percent = None 
     217        self.dx_old = False 
    215218        self.dxl = None 
    216219        self.dxw = None 
     
    339342        obj.dq_l = copy.deepcopy(self.dq_l) 
    340343        obj.dq_r = copy.deepcopy(self.dq_r) 
    341         obj.dx_max = copy.deepcopy(self.dx_max) 
    342         obj.dx_min = copy.deepcopy(self.dx_min) 
     344        obj.dx_percent = copy.deepcopy(self.dx_percent) 
     345        obj.dx_old = copy.deepcopy(self.dx_old) 
    343346        obj.dxl = copy.deepcopy(self.dxl) 
    344347        obj.dxw = copy.deepcopy(self.dxw) 
     
    366369        :return: None 
    367370        """ 
     371        if self.categorycombobox == CUSTOM_MODEL_OLD: 
     372            self.categorycombobox = CUSTOM_MODEL 
    368373        if self.formfactorcombobox == '': 
    369374            FIRST_FORM = { 
     
    378383                'Sphere' : 'adsorbed_layer', 
    379384                'Structure Factor' : 'hardsphere', 
    380                 'Customized Models' : '' 
     385                CUSTOM_MODEL : '' 
    381386            } 
    382387            if self.categorycombobox == '': 
     
    556561        rep += "dq_l  : %s\n" % self.dq_l 
    557562        rep += "dq_r  : %s\n" % self.dq_r 
    558         rep += "dx_max  : %s\n" % str(self.dx_max) 
    559         rep += "dx_min : %s\n" % str(self.dx_min) 
     563        rep += "dx_percent  : %s\n" % str(self.dx_percent) 
    560564        rep += "dxl  : %s\n" % str(self.dxl) 
    561565        rep += "dxw : %s\n" % str(self.dxw) 
     
    815819 
    816820        attr = newdoc.createAttribute("version") 
    817         import sasview 
     821        from sas import sasview 
    818822        attr.nodeValue = sasview.__version__ 
    819823        # attr.nodeValue = '1.0' 
     
    10421046                    setattr(self, item[0], parse_entry_helper(node, item)) 
    10431047 
     1048                dx_old_node = get_content('ns:%s' % 'dx_min', entry) 
    10441049                for item in LIST_OF_STATE_ATTRIBUTES: 
    1045                     node = get_content('ns:%s' % item[0], entry) 
    1046                     setattr(self, item[0], parse_entry_helper(node, item)) 
     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)) 
    10471058 
    10481059                for item in LIST_OF_STATE_PARAMETERS: 
  • src/sas/sasgui/plottools/plottables.py

    r345e7e4 ra9f579c  
    10231023    """ 
    10241024 
    1025     def __init__(self, x, y, dx=None, dy=None): 
     1025    def __init__(self, x, y, dx=None, dy=None, lam=None, dlam=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 
    10391040        self.dx = dx 
    10401041        self.dy = dy 
     1042        self.dlam = dlam 
    10411043        self.source = None 
    10421044        self.detector = None 
Note: See TracChangeset for help on using the changeset viewer.