Changeset 50f1477 in sasview


Ignore:
Timestamp:
Dec 19, 2016 5:25:08 AM (7 years ago)
Author:
GitHub <noreply@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
09fdc89, b61bd57
Parents:
f2724b6 (diff), 345e7e4 (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.
git-author:
jhbakker <j.h.bakker@…> (12/19/16 05:25:08)
git-committer:
GitHub <noreply@…> (12/19/16 05:25:08)
Message:

Merge pull request #27 from SasView?/revert-26-Jurtest2

Revert "Jurtest2"

Location:
src/sas
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • src/sas/sascalc/data_util/qsmearing.py

    rc6728e1 r345e7e4  
    55#This software was developed by the University of Tennessee as part of the 
    66#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    7 #project funded by the US National Science Foundation. 
     7#project funded by the US National Science Foundation.  
    88#See the license text in license.txt 
    99#copyright 2008, University of Tennessee 
     
    1313import logging 
    1414import sys 
    15 from sasmodels import sesans 
    16 import numpy as np  # type: ignore 
    17 from numpy import pi, exp  # type: ignore 
    1815 
    1916from sasmodels.resolution import Slit1D, Pinhole1D 
    20 from sasmodels.sesans import SESANS1D 
    2117from sasmodels.resolution2d import Pinhole2D 
    22 from src.sas.sascalc.data_util.nxsunit import Converter 
    23  
    2418 
    2519def smear_selection(data, model = None): 
     
    4236    # Sanity check. If we are not dealing with a SAS Data1D 
    4337    # object, just return None 
    44  
    45     # This checks for 2D data (does not throw exception because fail is common) 
    4638    if  data.__class__.__name__ not in ['Data1D', 'Theory1D']: 
    4739        if data == None: 
     
    5042            return None 
    5143        return Pinhole2D(data) 
    52     # This checks for 1D data with smearing info in the data itself (again, fail is likely; no exceptions) 
     44 
    5345    if  not hasattr(data, "dx") and not hasattr(data, "dxl")\ 
    5446         and not hasattr(data, "dxw"): 
     
    5648 
    5749    # Look for resolution smearing data 
    58     # This is the code that checks for SESANS data; it looks for the file loader 
    59     # TODO: change other sanity checks to check for file loader instead of data structure? 
    60     _found_sesans = False 
    61     #if data.dx is not None and data.meta_data['loader']=='SESANS': 
    62     if data.dx is not None and data.isSesans: 
    63         #if data.dx[0] > 0.0: 
    64         if numpy.size(data.dx[data.dx <= 0]) == 0: 
    65             _found_sesans = True 
    66         #if data.dx[0] <= 0.0: 
    67         if numpy.size(data.dx[data.dx <= 0]) > 0: 
    68             raise ValueError('one or more of your dx values are negative, please check the data file!') 
    69     if _found_sesans == True: 
    70         #Pre-compute the Hankel matrix (H) 
    71         qmax, qunits = data.sample.zacceptance 
    72         hankel=sesans.SesansTransform() 
    73         sesans.SesansTransform.set_transform(hankel, 
    74         SE = Converter(data._xunit)(data.x, "A"), 
    75         zaccept = Converter(qunits)(qmax, "1/A"), 
    76         Rmax = 10000000) 
    77         # Then return the actual transform, as if it were a smearing function 
    78         return PySmear(SESANS1D(data, hankel._H0, hankel._H, hankel.q), model) 
    79  
    8050    _found_resolution = False 
    8151    if data.dx is not None and len(data.dx) == len(data.x): 
     
    12292        self.model = model 
    12393        self.resolution = resolution 
    124         if hasattr(self.resolution, 'data'): 
    125             if self.resolution.data.meta_data['loader'] == 'SESANS': # Always True if file extension is '.ses'! 
    126                 self.offset = 0 
    127             # This is default behaviour, for future resolution/transform functions this needs to be revisited. 
    128             else: 
    129                 self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    130         else: 
    131             self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    132  
    133         #self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     94        self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    13495 
    13596    def apply(self, iq_in, first_bin=0, last_bin=None): 
     
    165126        q[first:last+1]. 
    166127        """ 
    167  
    168128        q = self.resolution.q 
    169129        first = numpy.searchsorted(q, q_min) 
  • src/sas/sascalc/dataloader/data_info.py

    r1fac6c0 r345e7e4  
    2525import numpy 
    2626import math 
     27 
     28class plottable_sesans1D(object): 
     29    """ 
     30    SESANS is a place holder for 1D SESANS plottables. 
     31 
     32    #TODO: This was directly copied from the plottables_1D. Modified Somewhat. 
     33    #Class has been updated. 
     34    """ 
     35    # The presence of these should be mutually 
     36    # exclusive with the presence of Qdev (dx) 
     37    x = None 
     38    y = None 
     39    lam = None 
     40    dx = None 
     41    dy = None 
     42    dlam = None 
     43    ## Slit smearing length 
     44    dxl = None 
     45    ## Slit smearing width 
     46    dxw = None 
     47 
     48    # Units 
     49    _xaxis = '' 
     50    _xunit = '' 
     51    _yaxis = '' 
     52    _yunit = '' 
     53 
     54    def __init__(self, x, y, lam, dx=None, dy=None, dlam=None): 
     55#        print "SESANS plottable working" 
     56        self.x = numpy.asarray(x) 
     57        self.y = numpy.asarray(y) 
     58        self.lam = numpy.asarray(lam) 
     59        if dx is not None: 
     60            self.dx = numpy.asarray(dx) 
     61        if dy is not None: 
     62            self.dy = numpy.asarray(dy) 
     63        if dlam is not None: 
     64            self.dlam = numpy.asarray(dlam) 
     65 
     66    def xaxis(self, label, unit): 
     67        """ 
     68        set the x axis label and unit 
     69        """ 
     70        self._xaxis = label 
     71        self._xunit = unit 
     72 
     73    def yaxis(self, label, unit): 
     74        """ 
     75        set the y axis label and unit 
     76        """ 
     77        self._yaxis = label 
     78        self._yunit = unit 
     79 
     80 
    2781class plottable_1D(object): 
    2882    """ 
     
    4094    dxw = None 
    4195 
    42     ## SESANS specific params (wavelengths for spin echo length calculation) 
    43  
    44     lam = None 
    45     dlam = None 
    46  
    4796    # Units 
    4897    _xaxis = '' 
     
    51100    _yunit = '' 
    52101 
    53     def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None, lam=None, dlam=None): 
     102    def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None): 
    54103        self.x = numpy.asarray(x) 
    55104        self.y = numpy.asarray(y) 
     
    62111        if dxw is not None: 
    63112            self.dxw = numpy.asarray(dxw) 
    64         if lam is not None: 
    65             self.lam = numpy.asarray(lam) 
    66         if dlam is not None: 
    67             self.dlam = numpy.asarray(dlam) 
    68113 
    69114    def xaxis(self, label, unit): 
     
    691736        return self._perform_union(other) 
    692737 
    693 class Data1D(plottable_1D, DataInfo): 
    694     """ 
    695     1D data class 
    696     """ 
    697     #if plottable_1D.lam is None: # This means it's SANS data! 
    698      #   x_unit = '1/A' 
    699       #  y_unit = '1/cm' 
    700     #elif plottable_1D.lam is not None: # This means it's SESANS data! 
    701      #   x_unit = 'A' 
    702       #  y_unit = 'pol' 
    703     #else: # and if it's neither, you get punished! 
    704      #   raise(TypeError,'This is neither SANS nor SESANS data, what the hell are you doing??') 
    705  
    706     def __init__(self, x=None, y=None, dx=None, dy=None, lam=None, dlam=None, isSesans=False): 
    707         self.isSesans = isSesans 
     738class SESANSData1D(plottable_sesans1D, DataInfo): 
     739    """ 
     740    SESANS 1D data class 
     741    """ 
     742    x_unit = 'nm' 
     743    y_unit = 'pol' 
     744 
     745    def __init__(self, x=None, y=None, lam=None, dx=None, dy=None, dlam=None): 
    708746        DataInfo.__init__(self) 
    709         plottable_1D.__init__(self, x, y, dx, dy,None, None, lam, dlam) 
    710         if self.isSesans: 
    711             x_unit = 'A' 
    712             y_unit = 'pol' 
    713         elif not self.isSesans: # it's SANS data! (Could also be simple else statement, but i prefer exhaustive conditionals...-JHB) 
    714             x_unit = '1/A' 
    715             y_unit = '1/cm' 
    716         else: # and if it's neither, you get punished! 
    717             raise(TypeError,'This is neither SANS nor SESANS data, what the hell are you doing??') 
     747        plottable_sesans1D.__init__(self, x, y, lam, dx, dy, dlam) 
    718748 
    719749    def __str__(self): 
     
    729759        return _str 
    730760 
     761    def clone_without_data(self, length=0, clone=None): 
     762        """ 
     763        Clone the current object, without copying the data (which 
     764        will be filled out by a subsequent operation). 
     765        The data arrays will be initialized to zero. 
     766 
     767        :param length: length of the data array to be initialized 
     768        :param clone: if provided, the data will be copied to clone 
     769        """ 
     770        from copy import deepcopy 
     771        if clone is None or not issubclass(clone.__class__, Data1D): 
     772            x = numpy.zeros(length) 
     773            dx = numpy.zeros(length) 
     774            y = numpy.zeros(length) 
     775            dy = numpy.zeros(length) 
     776            clone = Data1D(x, y, dx=dx, dy=dy) 
     777 
     778        clone.title = self.title 
     779        clone.run = self.run 
     780        clone.filename = self.filename 
     781        clone.instrument = self.instrument 
     782        clone.notes = deepcopy(self.notes) 
     783        clone.process = deepcopy(self.process) 
     784        clone.detector = deepcopy(self.detector) 
     785        clone.sample = deepcopy(self.sample) 
     786        clone.source = deepcopy(self.source) 
     787        clone.collimation = deepcopy(self.collimation) 
     788        clone.trans_spectrum = deepcopy(self.trans_spectrum) 
     789        clone.meta_data = deepcopy(self.meta_data) 
     790        clone.errors = deepcopy(self.errors) 
     791 
     792        return clone 
     793 
     794class Data1D(plottable_1D, DataInfo): 
     795    """ 
     796    1D data class 
     797    """ 
     798    x_unit = '1/A' 
     799    y_unit = '1/cm' 
     800 
     801    def __init__(self, x, y, dx=None, dy=None): 
     802        DataInfo.__init__(self) 
     803        plottable_1D.__init__(self, x, y, dx, dy) 
     804 
     805    def __str__(self): 
     806        """ 
     807        Nice printout 
     808        """ 
     809        _str = "%s\n" % DataInfo.__str__(self) 
     810        _str += "Data:\n" 
     811        _str += "   Type:         %s\n" % self.__class__.__name__ 
     812        _str += "   X-axis:       %s\t[%s]\n" % (self._xaxis, self._xunit) 
     813        _str += "   Y-axis:       %s\t[%s]\n" % (self._yaxis, self._yunit) 
     814        _str += "   Length:       %g\n" % len(self.x) 
     815        return _str 
     816 
    731817    def is_slit_smeared(self): 
    732818        """ 
     
    757843            y = numpy.zeros(length) 
    758844            dy = numpy.zeros(length) 
    759             lam = numpy.zeros(length) 
    760             dlam = numpy.zeros(length) 
    761             clone = Data1D(x, y, lam=lam, dx=dx, dy=dy, dlam=dlam ) 
     845            clone = Data1D(x, y, dx=dx, dy=dy) 
    762846 
    763847        clone.title = self.title 
  • src/sas/sascalc/dataloader/readers/sesans_reader.py

    ra01af35 r345e7e4  
    88import numpy 
    99import os 
    10 from sas.sascalc.dataloader.data_info import Data1D 
     10from sas.sascalc.dataloader.data_info import SESANSData1D 
    1111 
    1212# Check whether we have a converter available 
     
    5959                    raise  RuntimeError, "sesans_reader: cannot open %s" % path 
    6060                buff = input_f.read() 
     61#                print buff 
    6162                lines = buff.splitlines() 
     63#                print lines 
     64                #Jae could not find python universal line spliter: 
     65                #keep the below for now 
     66                # some ascii data has \r line separator, 
     67                # try it when the data is on only one long line 
     68#                if len(lines) < 2 : 
     69#                    lines = buff.split('\r') 
     70                  
    6271                x  = numpy.zeros(0) 
    6372                y  = numpy.zeros(0) 
     
    7483                tdlam = numpy.zeros(0) 
    7584                tdx = numpy.zeros(0) 
    76                 output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True ) 
     85#                print "all good" 
     86                output = SESANSData1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam) 
     87#                print output                 
    7788                self.filename = output.filename = basename 
    7889 
     90#                #Initialize counters for data lines and header lines. 
     91#                is_data = False  # Has more than 5 lines 
     92#                # More than "5" lines of data is considered as actual 
     93#                # data unless that is the only data 
     94#                mum_data_lines = 5 
     95#                # To count # of current data candidate lines 
     96#                i = -1 
     97#                # To count total # of previous data candidate lines 
     98#                i1 = -1 
     99#                # To count # of header lines 
     100#                j = -1 
     101#                # Helps to count # of header lines 
     102#                j1 = -1 
     103#                #minimum required number of columns of data; ( <= 4). 
     104#                lentoks = 2 
    79105                paramnames=[] 
    80106                paramvals=[] 
     
    85111                Pvals=[] 
    86112                dPvals=[] 
     113#                print x 
     114#                print zvals 
    87115                for line in lines: 
    88116                    # Initial try for CSV (split on ,) 
     
    94122                    if len(toks)>5: 
    95123                        zvals.append(toks[0]) 
    96                         dzvals.append(toks[3]) 
    97                         lamvals.append(toks[4]) 
    98                         dlamvals.append(toks[5]) 
    99                         Pvals.append(toks[1]) 
    100                         dPvals.append(toks[2]) 
     124                        dzvals.append(toks[1]) 
     125                        lamvals.append(toks[2]) 
     126                        dlamvals.append(toks[3]) 
     127                        Pvals.append(toks[4]) 
     128                        dPvals.append(toks[5]) 
    101129                    else: 
    102130                        continue 
     
    112140                default_z_unit = "A" 
    113141                data_conv_P = None 
    114                 default_p_unit = " " # Adjust unit for axis (L^-3) 
     142                default_p_unit = " " 
    115143                lam_unit = lam_header[1].replace("[","").replace("]","") 
    116                 if lam_unit == 'AA': 
    117                     lam_unit = 'A' 
    118144                varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]] 
    119145                valrange=range(1, len(zvals)) 
     
    135161                output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit) 
    136162                output.y = y 
    137                 output.y_unit = '\AA^{-2} cm^{-1}' # output y_unit erbij 
    138163                output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit) 
    139164                output.dy = dy 
     
    141166                output.dlam, output.dlam_unit = self._unit_conversion(dlam, lam_unit, default_z_unit) 
    142167 
    143                 output.xaxis("\\rm{z}", output.x_unit) 
    144                 output.yaxis("\\rm{ln(P)/(t \lambda^2)}", output.y_unit) # Adjust label to ln P/(lam^2 t), remove lam column refs 
     168                output.xaxis("\rm{z}", output.x_unit) 
     169                output.yaxis("\\rm{P/P0}", output.y_unit) 
    145170                # Store loading process information 
    146171                output.meta_data['loader'] = self.type_name 
    147                 #output.sample.thickness = float(paramvals[6]) 
     172                output.sample.thickness = float(paramvals[6]) 
    148173                output.sample.name = paramvals[1] 
    149174                output.sample.ID = paramvals[0] 
    150175                zaccept_unit_split = paramnames[7].split("[") 
    151176                zaccept_unit = zaccept_unit_split[1].replace("]","") 
    152                 if zaccept_unit.strip() == '\AA^-1' or zaccept_unit.strip() == '\A^-1': 
     177                if zaccept_unit.strip() == '\AA^-1': 
    153178                    zaccept_unit = "1/A" 
    154179                output.sample.zacceptance=(float(paramvals[7]),zaccept_unit) 
  • src/sas/sascalc/fit/AbstractFitEngine.py

    r7988501 r345e7e4  
    131131        a way to get residuals from data. 
    132132    """ 
    133     def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None, lam=None, dlam=None): 
     133    def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None): 
    134134        """ 
    135135            :param smearer: is an object of class QSmearer or SlitSmearer 
     
    152152                 
    153153        """ 
    154         Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy, lam=lam,dlam=dlam) 
     154        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy) 
    155155        self.num_points = len(x) 
    156156        self.sas_data = data 
  • src/sas/sascalc/fit/BumpsFitting.py

    rf668101 r345e7e4  
    2727from bumps import parameter 
    2828from bumps.fitproblem import FitProblem 
     29 
    2930 
    3031from sas.sascalc.fit.AbstractFitEngine import FitEngine 
  • src/sas/sasgui/guiframe/dataFitting.py

    r1fac6c0 r345e7e4  
    1717    """ 
    1818    """ 
    19     def __init__(self, x=None, y=None, dx=None, dy=None, lam=None, dlam=None, isSesans=False): 
     19    def __init__(self, x=None, y=None, dx=None, dy=None): 
    2020        """ 
    2121        """ 
     
    2424        if y is None: 
    2525            y = [] 
    26         self.isSesans = isSesans 
    27         PlotData1D.__init__(self, x, y, dx, dy, lam, dlam) 
    28         LoadData1D.__init__(self, x, y, dx, dy, lam, dlam, isSesans) 
     26        PlotData1D.__init__(self, x, y, dx, dy) 
     27        LoadData1D.__init__(self, x, y, dx, dy) 
    2928        self.id = None 
    3029        self.list_group_id = [] 
     
    6968        # First, check the data compatibility 
    7069        dy, dy_other = self._validity_check(other) 
    71         result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=None) 
     70        result = Data1D(x=[], y=[], dx=None, dy=None) 
    7271        result.clone_without_data(length=len(self.x), clone=self) 
    7372        result.copy_from_datainfo(data1d=self) 
     
    116115        # First, check the data compatibility 
    117116        self._validity_check_union(other) 
    118         result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=None) 
     117        result = Data1D(x=[], y=[], dx=None, dy=None) 
    119118        tot_length = len(self.x) + len(other.x) 
    120119        result = self.clone_without_data(length=tot_length, clone=result) 
    121         if self.dlam == None or other.dlam is None: 
    122             result.dlam = None 
    123         else: 
    124             result.dlam = numpy.zeros(tot_length) 
    125120        if self.dy == None or other.dy is None: 
    126121            result.dy = None 
     
    146141        result.y = numpy.append(self.y, other.y) 
    147142        result.y = result.y[ind] 
    148         result.lam = numpy.append(self.lam, other.lam) 
    149         result.lam = result.lam[ind] 
    150         if result.dlam != None: 
    151             result.dlam = numpy.append(self.dlam, other.dlam) 
    152             result.dlam = result.dlam[ind] 
    153143        if result.dy != None: 
    154144            result.dy = numpy.append(self.dy, other.dy) 
     
    270260        # First, check the data compatibility 
    271261        self._validity_check_union(other) 
    272         result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=[]) 
     262        result = Data1D(x=[], y=[], dx=None, dy=None) 
    273263        tot_length = len(self.x)+len(other.x) 
    274264        result.clone_without_data(length=tot_length, clone=self) 
    275         if self.dlam == None or other.dlam is None: 
    276             result.dlam = None 
    277         else: 
    278             result.dlam = numpy.zeros(tot_length) 
    279265        if self.dy == None or other.dy is None: 
    280266            result.dy = None 
     
    299285        result.y = numpy.append(self.y, other.y) 
    300286        result.y = result.y[ind] 
    301         result.lam = numpy.append(self.lam, other.lam) 
    302         result.lam = result.lam[ind] 
    303287        if result.dy != None: 
    304288            result.dy = numpy.append(self.dy, other.dy) 
  • src/sas/sasgui/guiframe/data_manager.py

    r1fac6c0 r345e7e4  
    6262        if issubclass(Data2D, data.__class__): 
    6363            new_plot = Data2D(image=None, err_image=None)  
    64         elif data.meta_data['loader'] == 'SESANS': 
    65             new_plot = Data1D(x=[], y=[], dx=None, dy=None, lam=None, dlam=None, isSesans=True) 
    66         else: 
    67             new_plot = Data1D(x=[], y=[], dx=None, dy=None, lam=None, dlam=None) #SESANS check??? 
     64        else:  
     65            new_plot = Data1D(x=[], y=[], dx=None, dy=None) 
    6866            
    6967        new_plot.copy_from_datainfo(data) 
  • src/sas/sasgui/perspectives/fitting/basepage.py

    r55bc5a7f r345e7e4  
    143143        self.theory_qmin_x = None 
    144144        self.theory_qmax_x = None 
    145         self.cb1 = None 
    146145        self.btEditMask = None 
    147146        self.btFit = None 
     
    282281                           num=self.npts_x, endpoint=True) 
    283282        self.data = Data1D(x=x) 
    284         #self.data.xaxis('\\rm{Q}', "A^{-1}") 
    285         self.data.xaxis('\\rm{X}', "") 
    286         #self.data.yaxis('\\rm{Intensity}', "cm^{-1}") 
    287         self.data.yaxis('\\rm{Y}', "") 
     283        self.data.xaxis('\\rm{Q}', "A^{-1}") 
     284        self.data.yaxis('\\rm{Intensity}', "cm^{-1}") 
    288285        self.data.is_data = False 
    289286        self.data.id = str(self.uid) + " data" 
     
    310307                           num=self.npts_x, endpoint=True, base=10.0) 
    311308        self.data = Data1D(x=x) 
    312         #self.data.xaxis('\\rm{Q}', "A^{-1}") 
    313         #self.data.yaxis('\\rm{Intensity}', "cm^{-1}") 
    314         self.data.xaxis('\\rm{X}', "") 
    315         self.data.yaxis('\\rm{Y}', "") 
     309        self.data.xaxis('\\rm{Q}', "A^{-1}") 
     310        self.data.yaxis('\\rm{Intensity}', "cm^{-1}") 
    316311        self.data.is_data = False 
    317312        self.data.id = str(self.uid) + " data" 
     
    11291124        # set data, etc. from the state 
    11301125        # reset page between theory and fitting from bookmarking 
    1131         #if state.data == None: 
    1132         #    data = None 
    1133         #else: 
    11341126        data = state.data 
    11351127 
     
    13481340                        except Exception: 
    13491341                            logging.error(traceback.format_exc()) 
    1350  
    1351         # Make sure the check box updated when all checked 
    1352         if self.cb1.GetValue(): 
    1353             self.select_all_param(None) 
    13541342 
    13551343    def _selectDlg(self): 
     
    24932481                        item[2].Enable() 
    24942482 
    2495             # Make sure the check box updated when all checked 
    2496             if self.cb1.GetValue(): 
    2497                 #self.select_all_param(None) 
    2498                 self.get_all_checked_params() 
     2483            # Make sure the check box updated 
     2484            self.get_all_checked_params() 
    24992485 
    25002486            # update params 
     
    36753661        call back for model selection if implemented 
    36763662        """ 
    3677     def select_all_param(self, event): 
    3678         """ 
    3679         set to true or false all checkBox if implemented 
    3680         """ 
    36813663    def get_weight_flag(self): 
    36823664        """ 
  • src/sas/sasgui/perspectives/fitting/fitpage.py

    rf668101 r345e7e4  
    168168            self.set_data(data) 
    169169        elif self.dataSource.GetCount() > 0: 
    170  
    171170            pos = self.dataSource.GetSelection() 
    172171            data = self.dataSource.GetClientData(pos) 
     
    618617        # fill a sizer with the combobox to select dispersion type 
    619618        model_disp = wx.StaticText(self, wx.ID_ANY, 'Function') 
    620         CHECK_STATE = self.cb1.GetValue() 
     619        CHECK_STATE = False 
    621620 
    622621        ix = 0 
     
    962961 
    963962        self.state.model = self.model.clone() 
    964  
    965963        # save state into 
    966964        self._copy_parameters_state(self.parameters, self.state.parameters) 
     
    973971        wx.PostEvent(self.parent, 
    974972                     StatusEvent(status=" Selected Distribution: Gaussian")) 
    975  
    976973        # Fill the list of fittable parameters 
    977974        self.get_all_checked_params() 
     
    26852682        self._manager.set_param2fit(self.uid, param2fit) 
    26862683 
    2687  
    26882684    def select_param(self, event=None): 
    26892685        """ 
     
    27322728        if len(self.fittable_param) > 0: 
    27332729            len_orient_para *= 2 
    2734         #Set the value of checkbox that selected every checkbox or not 
    2735         if len(self.parameters) + len(self.fittable_param) - len_orient_para \ 
    2736             == len(self.param_toFit): 
    2737             self.cb1.SetValue(True) 
    2738         else: 
    2739             self.cb1.SetValue(False) 
    27402730 
    27412731        self.save_current_state_fit() 
     
    28392829        iy = 0 
    28402830        ix = 0 
    2841         select_text = "Select All" 
    2842         self.cb1 = wx.CheckBox(self, wx.ID_ANY, str(select_text), (10, 10)) 
    2843         wx.EVT_CHECKBOX(self, self.cb1.GetId(), self.select_all_param) 
    2844         self.cb1.SetToolTipString("To check/uncheck all the boxes below.") 
    2845         self.cb1.SetValue(True) 
    2846  
    2847         sizer.Add(self.cb1, (iy, ix), (1, 1), \ 
    2848                              wx.LEFT | wx.EXPAND | wx.ADJUST_MINSIZE, 5) 
     2831        sizer.Add(wx.StaticText(self, wx.ID_ANY, 'Parameter'), 
     2832                  (iy, ix), (1, 1), wx.EXPAND | wx.ADJUST_MINSIZE, 0) 
    28492833        ix += 1 
    28502834        self.text2_2 = wx.StaticText(self, wx.ID_ANY, 'Value') 
     
    28732857        self.text2_4.Hide() 
    28742858 
    2875         CHECK_STATE = self.cb1.GetValue() 
     2859        CHECK_STATE = False 
    28762860        for item in keys: 
    28772861 
  • src/sas/sasgui/plottools/plottables.py

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