Changeset 7caf3e5 in sasview for src/sas


Ignore:
Timestamp:
Feb 24, 2017 9:39:00 AM (8 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:
c221349
Parents:
2ffe241 (diff), cb05bfd (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:
Paul Kienzle <pkienzle@…> (02/24/17 09:39:00)
git-committer:
GitHub <noreply@…> (02/24/17 09:39:00)
Message:

Merge branch 'master' into sesans41

Location:
src/sas
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    rb5db35d r7caf3e5  
    136136                output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit) 
    137137                output.y = y 
    138                 output.y_unit = '\AA^{-2} cm^{-1}'  # output y_unit added 
     138                output.y_unit = r'\AA^{-2} cm^{-1}'  # output y_unit added 
    139139                output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit) 
    140140                output.dy = dy 
    141141                output.lam, output.lam_unit = self._unit_conversion(lam, lam_unit, default_z_unit) 
    142142                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 
    143146 
    144                 output.xaxis("\\rm{z}", output.x_unit) 
    145                 output.yaxis("\\rm{ln(P)/(t \lambda^2)}", output.y_unit)  # Adjust label to ln P/(lam^2 t), remove lam column refs 
    146147                # Store loading process information 
    147148                output.meta_data['loader'] = self.type_name 
    … …  
    151152                zaccept_unit_split = paramnames[7].split("[") 
    152153                zaccept_unit = zaccept_unit_split[1].replace("]","") 
    153                 if zaccept_unit.strip() == '\AA^-1' or zaccept_unit.strip() == '\A^-1': 
     154                if zaccept_unit.strip() == r'\AA^-1' or zaccept_unit.strip() == r'\A^-1': 
    154155                    zaccept_unit = "1/A" 
    155156                output.sample.zacceptance=(float(paramvals[7]),zaccept_unit) 

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

    ra6fccd7 r3d55219  
    362362        self.Bind(wx.EVT_RADIOBUTTON, self.onSlitSmear, 
    363363                  id=self.slit_smearer.GetId()) 
    364         self.enable_smearer.SetValue(True) 
     364        self.disable_smearer.SetValue(True) 
    365365 
    366366        sizer_smearer.Add(self.disable_smearer, 0, wx.LEFT, 10) 
    … …  
    19341934 
    19351935            # more disables for 2D 
     1936            di_flag = False 
     1937            dq_flag = False 
    19361938            if self.data.__class__.__name__ == "Data2D" or \ 
    19371939                        self.enable2D: 
    … …  
    19391941                self.pinhole_smearer.Enable(True) 
    19401942                self.default_mask = copy.deepcopy(self.data.mask) 
    1941                 if self.data.err_data is None or\ 
    1942                         numpy.all(err == 1 for err in self.data.err_data) or \ 
    1943                         not numpy.any(self.data.err_data): 
    1944                     self.dI_didata.Enable(False) 
    1945                     self.dI_noweight.SetValue(True) 
    1946                     self.weightbt_string = self.dI_noweight.GetLabelText() 
    1947                 else: 
    1948                     self.dI_didata.Enable(True) 
    1949                     self.dI_didata.SetValue(True) 
    1950                     self.weightbt_string = self.dI_didata.GetLabelText() 
     1943                if self.data.err_data is not None \ 
     1944                        and numpy.any(self.data.err_data): 
     1945                    di_flag = True 
     1946                if self.data.dqx_data is not None \ 
     1947                        and numpy.any(self.data.dqx_data): 
     1948                    dq_flag = True 
    19511949            else: 
    19521950                self.slit_smearer.Enable(True) 
    19531951                self.pinhole_smearer.Enable(True) 
    1954  
    1955                 if self.data.dy is None or\ 
    1956                      numpy.all(self.data.dy == 1) or\ 
    1957                      not numpy.any(self.data.dy): 
    1958                     self.dI_didata.Enable(False) 
    1959                     self.dI_noweight.SetValue(True) 
    1960                     self.weightbt_string = self.dI_noweight.GetLabelText() 
    1961                 else: 
    1962                     self.dI_didata.Enable(True) 
    1963                     self.dI_didata.SetValue(True) 
    1964                     self.weightbt_string = self.dI_didata.GetLabelText() 
     1952                if self.data.dy is not None and numpy.any(self.data.dy): 
     1953                    di_flag = True 
     1954                if self.data.dx is not None and numpy.any(self.data.dx): 
     1955                    dq_flag = True 
     1956                elif self.data.dxl is not None and numpy.any(self.data.dxl): 
     1957                    dq_flag = True 
     1958 
     1959            if dq_flag: 
     1960                self.enable_smearer.Enable(True) 
     1961                self.enable_smearer.SetValue(True) 
     1962                self.disable_smearer.SetValue(False) 
     1963            else: 
     1964                self.enable_smearer.Disable() 
     1965                self.disable_smearer.Enable(True) 
     1966                self.disable_smearer.SetValue(True) 
     1967 
     1968            if di_flag: 
     1969                self.dI_didata.Enable(True) 
     1970                self.dI_didata.SetValue(True) 
     1971                self.weightbt_string = self.dI_didata.GetLabelText() 
     1972            else: 
     1973                self.dI_didata.Enable(False) 
     1974                self.dI_noweight.SetValue(True) 
     1975                self.weightbt_string = self.dI_noweight.GetLabelText() 
     1976 
    19651977            # Enable weighting radio buttons 
    19661978            self.dI_noweight.Enable(True) 
    … …  
    20042016            self.EditMask_title.Disable() 
    20052017 
     2018        self.onSmear(event=None) 
    20062019        self.on_set_focus(None) 
    20072020        self.Refresh() 

  • src/sas/sascalc/data_util/qsmearing.py

    rd3911e3 r2ffe241  
    1313import logging 
    1414import sys 
    15  
     15import numpy as np  # type: ignore 
     16from numpy import pi, exp # type:ignore 
    1617from sasmodels.resolution import Slit1D, Pinhole1D 
     18from sasmodels.sesans import SesansTransform 
    1719from sasmodels.resolution2d import Pinhole2D 
     20from src.sas.sascalc.data_util.nxsunit import Converter 
    1821 
    1922def smear_selection(data, model = None): 
    … …  
    3639    # Sanity check. If we are not dealing with a SAS Data1D 
    3740    # object, just return None 
     41    # This checks for 2D data (does not throw exception because fail is common) 
    3842    if  data.__class__.__name__ not in ['Data1D', 'Theory1D']: 
    3943        if data == None: 
    … …  
    4145        elif data.dqx_data == None or data.dqy_data == None: 
    4246            return None 
    43         return PySmear2D(data, model) 
    44  
     47        return PySmear2D(data) 
     48    # This checks for 1D data with smearing info in the data itself (again, fail is likely; no exceptions) 
    4549    if  not hasattr(data, "dx") and not hasattr(data, "dxl")\ 
    4650         and not hasattr(data, "dxw"): 
    … …  
    4852 
    4953    # Look for resolution smearing data 
     54    # This is the code that checks for SESANS data; it looks for the file loader 
     55    # TODO: change other sanity checks to check for file loader instead of data structure? 
     56    _found_sesans = False 
     57    #if data.dx is not None and data.meta_data['loader']=='SESANS': 
     58    if data.dx is not None and data.isSesans: 
     59        #if data.dx[0] > 0.0: 
     60        if numpy.size(data.dx[data.dx <= 0]) == 0: 
     61            _found_sesans = True 
     62        # if data.dx[0] <= 0.0: 
     63        if numpy.size(data.dx[data.dx <= 0]) > 0: 
     64            raise ValueError('one or more of your dx values are negative, please check the data file!') 
     65 
     66    if _found_sesans == True: 
     67        #Pre-compute the Hankel matrix (H) 
     68        qmax, qunits = data.sample.zacceptance 
     69        SElength = Converter(data._xunit)(data.x, "A") 
     70        zaccept = Converter(qunits)(qmax, "1/A"), 
     71        Rmax = 10000000 
     72        hankel = SesansTransform(data.x, SElength, zaccept, Rmax) 
     73        # Then return the actual transform, as if it were a smearing function 
     74        return PySmear(hankel, model, offset=0) 
     75 
    5076    _found_resolution = False 
    5177    if data.dx is not None and len(data.dx) == len(data.x): 
    … …  
    89115    Wrapper for pure python sasmodels resolution functions. 
    90116    """ 
    91     def __init__(self, resolution, model): 
     117    def __init__(self, resolution, model, offset=None): 
    92118        self.model = model 
    93119        self.resolution = resolution 
    94         self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     120        if offset is None: 
     121            offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     122        self.offset = offset 
    95123 
    96124    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 rb5e9ce26  
    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], unit_list[1]) 
     266                    else: 
     267                        self.current_dataset.yaxis("Intensity", unit) 
    264268                    self.current_dataset.y = np.append(self.current_dataset.y, data_point) 
    265269                elif tagname == 'Idev' and isinstance(self.current_dataset, plottable_1D): 
    266270                    self.current_dataset.dy = np.append(self.current_dataset.dy, data_point) 
    267271                elif tagname == 'Q': 
    268                     self.current_dataset.xaxis("Q", unit) 
     272                    unit_list = unit.split(" | ") 
     273                    if len(unit_list) > 1: 
     274                        self.current_dataset.xaxis(unit_list[0], unit_list[1]) 
     275                    else: 
     276                        self.current_dataset.xaxis("Q", unit) 
    269277                    self.current_dataset.x = np.append(self.current_dataset.x, data_point) 
    270278                elif tagname == 'Qdev': 
    … …  
    278286                elif tagname == 'Shadowfactor': 
    279287                    pass 
     288                elif tagname == 'Sesans': 
     289                    self.current_datainfo.isSesans = bool(data_point) 
     290                elif tagname == 'zacceptance': 
     291                    self.current_datainfo.sample.zacceptance = (data_point, unit) 
    280292 
    281293                # I and Qx, Qy - 2D data 
    … …  
    10201032            node.append(point) 
    10211033            self.write_node(point, "Q", datainfo.x[i], 
    1022                             {'unit': datainfo.x_unit}) 
     1034                            {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10231035            if len(datainfo.y) >= i: 
    10241036                self.write_node(point, "I", datainfo.y[i], 
    1025                                 {'unit': datainfo.y_unit}) 
     1037                                {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
    10261038            if datainfo.dy is not None and len(datainfo.dy) > i: 
    10271039                self.write_node(point, "Idev", datainfo.dy[i], 
    1028                                 {'unit': datainfo.y_unit}) 
     1040                                {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
    10291041            if datainfo.dx is not None and len(datainfo.dx) > i: 
    10301042                self.write_node(point, "Qdev", datainfo.dx[i], 
    1031                                 {'unit': datainfo.x_unit}) 
     1043                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10321044            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    10331045                self.write_node(point, "dQw", datainfo.dxw[i], 
    1034                                 {'unit': datainfo.x_unit}) 
     1046                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10351047            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    10361048                self.write_node(point, "dQl", datainfo.dxl[i], 
    1037                                 {'unit': datainfo.x_unit}) 
     1049                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
     1050        if datainfo.isSesans: 
     1051            sesans = self.create_element("Sesans") 
     1052            sesans.text = str(datainfo.isSesans) 
     1053            node.append(sesans) 
     1054            self.write_node(node, "zacceptance", datainfo.sample.zacceptance[0], 
     1055                             {'unit': datainfo.sample.zacceptance[1]}) 
     1056 
    10381057 
    10391058    def _write_data_2d(self, datainfo, entry_node): 

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