Changeset 0d64713 in sasview


Ignore:
Timestamp:
Feb 28, 2017 1:17:19 PM (2 years ago)
Author:
GitHub <noreply@…>
Children:
13043af
Parents:
46f798f
git-author:
Jeff Krzywon <krzywon@…> (02/28/17 13:17:19)
git-committer:
GitHub <noreply@…> (02/28/17 13:17:19)
Message:

Revert "Sesans41"

Files:
1 added
1 deleted
9 edited

Legend:

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

    r2ffe241 r0d64713  
    1313import logging 
    1414import sys 
    15 import numpy as np  # type: ignore 
    16 from numpy import pi, exp # type:ignore 
     15 
    1716from sasmodels.resolution import Slit1D, Pinhole1D 
    18 from sasmodels.sesans import SesansTransform 
    1917from sasmodels.resolution2d import Pinhole2D 
    20 from src.sas.sascalc.data_util.nxsunit import Converter 
    2118 
    2219def smear_selection(data, model = None): 
     
    3936    # Sanity check. If we are not dealing with a SAS Data1D 
    4037    # object, just return None 
    41     # This checks for 2D data (does not throw exception because fail is common) 
    4238    if  data.__class__.__name__ not in ['Data1D', 'Theory1D']: 
    4339        if data == None: 
     
    4541        elif data.dqx_data == None or data.dqy_data == None: 
    4642            return None 
    47         return PySmear2D(data) 
    48     # This checks for 1D data with smearing info in the data itself (again, fail is likely; no exceptions) 
     43        return PySmear2D(data, model) 
     44 
    4945    if  not hasattr(data, "dx") and not hasattr(data, "dxl")\ 
    5046         and not hasattr(data, "dxw"): 
     
    5248 
    5349    # 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  
    7650    _found_resolution = False 
    7751    if data.dx is not None and len(data.dx) == len(data.x): 
     
    11589    Wrapper for pure python sasmodels resolution functions. 
    11690    """ 
    117     def __init__(self, resolution, model, offset=None): 
     91    def __init__(self, resolution, model): 
    11892        self.model = model 
    11993        self.resolution = resolution 
    120         if offset is None: 
    121             offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    122         self.offset = offset 
     94        self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    12395 
    12496    def apply(self, iq_in, first_bin=0, last_bin=None): 
  • src/sas/sascalc/dataloader/data_info.py

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

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

    rc221349 r0d64713  
    261261                # I and Q - 1D data 
    262262                elif tagname == 'I' and isinstance(self.current_dataset, plottable_1D): 
    263                     unit_list = unit.split("|") 
    264                     if len(unit_list) > 1: 
    265                         self.current_dataset.yaxis(unit_list[0].strip(), 
    266                                                    unit_list[1].strip()) 
    267                     else: 
    268                         self.current_dataset.yaxis("Intensity", unit) 
     263                    self.current_dataset.yaxis("Intensity", unit) 
    269264                    self.current_dataset.y = np.append(self.current_dataset.y, data_point) 
    270265                elif tagname == 'Idev' and isinstance(self.current_dataset, plottable_1D): 
    271266                    self.current_dataset.dy = np.append(self.current_dataset.dy, data_point) 
    272267                elif tagname == 'Q': 
    273                     unit_list = unit.split("|") 
    274                     if len(unit_list) > 1: 
    275                         self.current_dataset.xaxis(unit_list[0].strip(), 
    276                                                    unit_list[1].strip()) 
    277                     else: 
    278                         self.current_dataset.xaxis("Q", unit) 
     268                    self.current_dataset.xaxis("Q", unit) 
    279269                    self.current_dataset.x = np.append(self.current_dataset.x, data_point) 
    280270                elif tagname == 'Qdev': 
     
    288278                elif tagname == 'Shadowfactor': 
    289279                    pass 
    290                 elif tagname == 'Sesans': 
    291                     self.current_datainfo.isSesans = bool(data_point) 
    292                 elif tagname == 'zacceptance': 
    293                     self.current_datainfo.sample.zacceptance = (data_point, unit) 
    294280 
    295281                # I and Qx, Qy - 2D data 
     
    10341020            node.append(point) 
    10351021            self.write_node(point, "Q", datainfo.x[i], 
    1036                             {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
     1022                            {'unit': datainfo.x_unit}) 
    10371023            if len(datainfo.y) >= i: 
    10381024                self.write_node(point, "I", datainfo.y[i], 
    1039                                 {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
     1025                                {'unit': datainfo.y_unit}) 
    10401026            if datainfo.dy is not None and len(datainfo.dy) > i: 
    10411027                self.write_node(point, "Idev", datainfo.dy[i], 
    1042                                 {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
     1028                                {'unit': datainfo.y_unit}) 
    10431029            if datainfo.dx is not None and len(datainfo.dx) > i: 
    10441030                self.write_node(point, "Qdev", datainfo.dx[i], 
    1045                                 {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
     1031                                {'unit': datainfo.x_unit}) 
    10461032            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    10471033                self.write_node(point, "dQw", datainfo.dxw[i], 
    1048                                 {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
     1034                                {'unit': datainfo.x_unit}) 
    10491035            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    10501036                self.write_node(point, "dQl", datainfo.dxl[i], 
    1051                                 {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    1052         if datainfo.isSesans: 
    1053             sesans = self.create_element("Sesans") 
    1054             sesans.text = str(datainfo.isSesans) 
    1055             node.append(sesans) 
    1056             self.write_node(node, "zacceptance", datainfo.sample.zacceptance[0], 
    1057                              {'unit': datainfo.sample.zacceptance[1]}) 
    1058  
     1037                                {'unit': datainfo.x_unit}) 
    10591038 
    10601039    def _write_data_2d(self, datainfo, entry_node): 
  • src/sas/sascalc/dataloader/readers/sesans_reader.py

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

    ra9f579c r0d64713  
    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/sasgui/guiframe/dataFitting.py

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

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

    ra9f579c r0d64713  
    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.