Changeset a9f579c in sasview


Ignore:
Timestamp:
Jan 17, 2017 2:18:58 PM (7 years ago)
Author:
jhbakker
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:
aad41bb
Parents:
ef0e644
Message:

Manually added in all the SESANS modifications from Jurtest

Location:
src/sas
Files:
8 edited

Legend:

Unmodified
Added
Removed

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

    rd3911e3 ra9f579c  
    1313import logging 
    1414import sys 
    15  
     15from sasmodels import sesans 
     16import numpy as np  # type: ignore 
     17from numpy import pi, exp # type:ignore 
    1618from sasmodels.resolution import Slit1D, Pinhole1D 
     19from sasmodels.sesans import SESANS1D 
    1720from sasmodels.resolution2d import Pinhole2D 
     21from src.sas.sascalc.data_util.nxsunit import Converter 
    1822 
    1923def smear_selection(data, model = None): 
    … …  
    3640    # Sanity check. If we are not dealing with a SAS Data1D 
    3741    # object, just return None 
     42    # This checks for 2D data (does not throw exception because fail is common) 
    3843    if  data.__class__.__name__ not in ['Data1D', 'Theory1D']: 
    3944        if data == None: 
    … …  
    4146        elif data.dqx_data == None or data.dqy_data == None: 
    4247            return None 
    43         return PySmear2D(data, model) 
    44  
     48        return Pinhole2D(data) 
     49    # This checks for 1D data with smearing info in the data itself (again, fail is likely; no exceptions) 
    4550    if  not hasattr(data, "dx") and not hasattr(data, "dxl")\ 
    4651         and not hasattr(data, "dxw"): 
    … …  
    4853 
    4954    # Look for resolution smearing data 
     55    # This is the code that checks for SESANS data; it looks for the file loader 
     56    # TODO: change other sanity checks to check for file loader instead of data structure? 
     57    _found_sesans = False 
     58    #if data.dx is not None and data.meta_data['loader']=='SESANS': 
     59    if data.dx is not None and data.isSesans: 
     60        #if data.dx[0] > 0.0: 
     61        if numpy.size(data.dx[data.dx <= 0]) == 0: 
     62            _found_sesans = True 
     63        # if data.dx[0] <= 0.0: 
     64        if numpy.size(data.dx[data.dx <= 0]) > 0: 
     65            raise ValueError('one or more of your dx values are negative, please check the data file!') 
     66 
     67    if _found_sesans == True: 
     68        #Pre-compute the Hankel matrix (H) 
     69        qmax, qunits = data.sample.zacceptance 
     70        hankel = sesans.SesansTransform() 
     71        sesans.SesansTransform.set_transform(hankel, 
     72        SE = Converter(data._xunit)(data.x, "A"), 
     73        zaccept = Converter(qunits)(qmax, "1/A"), 
     74        Rmax = 10000000) 
     75        # Then return the actual transform, as if it were a smearing function 
     76        return PySmear(SESANS1D(data, hankel._H0, hankel._H, hankel.q), model) 
     77 
    5078    _found_resolution = False 
    5179    if data.dx is not None and len(data.dx) == len(data.x): 
    … …  
    92120        self.model = model 
    93121        self.resolution = resolution 
    94         self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     122 
     123        if hasattr(self.resolution, 'data'): 
     124            if self.resolution.data.meta_data['loader'] == 'SESANS':  # Always True if file extension is '.ses'! 
     125                self.offset = 0 
     126            # This is default behaviour, for future resolution/transform functions this needs to be revisited. 
     127            else: 
     128                self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     129        else: 
     130            self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
     131 
     132        # self.offset = numpy.searchsorted(self.resolution.q_calc, self.resolution.q[0]) 
    95133 
    96134    def apply(self, iq_in, first_bin=0, last_bin=None): 

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

    r345e7e4 ra9f579c  
    9393    ## Slit smearing width 
    9494    dxw = None 
     95    ## SESANS specific params (wavelengths for spin echo length calculation) 
     96    lam = None 
     97    dlam = None 
    9598 
    9699    # Units 
    … …  
    100103    _yunit = '' 
    101104 
    102     def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None): 
     105    def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None, lam=None, dlam=None): 
    103106        self.x = numpy.asarray(x) 
    104107        self.y = numpy.asarray(y) 
    … …  
    111114        if dxw is not None: 
    112115            self.dxw = numpy.asarray(dxw) 
     116        if lam is not None: 
     117            self.lam = numpy.asarray(lam) 
     118        if dlam is not None: 
     119            self.dlam = numpy.asarray(dlam) 
    113120 
    114121    def xaxis(self, label, unit): 
    … …  
    736743        return self._perform_union(other) 
    737744 
    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): 
     745class Data1D(plottable_1D, DataInfo): 
     746    """ 
     747    1D data class 
     748    """ 
     749    def __init__(self, x=None, y=None, dx=None, dy=None, lam=None, dlam=None, isSesans=False): 
     750        self.isSesans = isSesans 
    746751        DataInfo.__init__(self) 
    747         plottable_sesans1D.__init__(self, x, y, lam, dx, dy, dlam) 
     752        plottable_1D.__init__(self, x, y, dx, dy,None, None, lam, dlam) 
     753        if self.isSesans: 
     754            x_unit = 'A' 
     755            y_unit = 'pol' 
     756        elif not self.isSesans: # it's SANS data! (Could also be simple else statement, but i prefer exhaustive conditionals...-JHB) 
     757            x_unit = '1/A' 
     758            y_unit = '1/cm' 
     759        else: # and if it's neither, you get punished! 
     760            raise(TypeError,'This is neither SANS nor SESANS data, what the hell are you doing??') 
    748761 
    749762    def __str__(self): 
    … …  
    759772        return _str 
    760773 
    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  
    817774    def is_slit_smeared(self): 
    818775        """ 
    … …  
    843800            y = numpy.zeros(length) 
    844801            dy = numpy.zeros(length) 
    845             clone = Data1D(x, y, dx=dx, dy=dy) 
     802            lam = numpy.zeros(length) 
     803            dlam = numpy.zeros(length) 
     804            clone = Data1D(x, y, lam=lam, dx=dx, dy=dy, dlam=dlam) 
    846805 
    847806        clone.title = self.title 

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

    r345e7e4 ra9f579c  
    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 = '\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 
    … …  
    166142                output.dlam, output.dlam_unit = self._unit_conversion(dlam, lam_unit, default_z_unit) 
    167143 
    168                 output.xaxis("\rm{z}", output.x_unit) 
    169                 output.yaxis("\\rm{P/P0}", output.y_unit) 
     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 
    170146                # Store loading process information 
    171147                output.meta_data['loader'] = self.type_name 
    172                 output.sample.thickness = float(paramvals[6]) 
     148                #output.sample.thickness = float(paramvals[6]) 
    173149                output.sample.name = paramvals[1] 
    174150                output.sample.ID = paramvals[0] 
    175151                zaccept_unit_split = paramnames[7].split("[") 
    176152                zaccept_unit = zaccept_unit_split[1].replace("]","") 
    177                 if zaccept_unit.strip() == '\AA^-1': 
     153                if zaccept_unit.strip() == '\AA^-1' or zaccept_unit.strip() == '\A^-1': 
    178154                    zaccept_unit = "1/A" 
    179155                output.sample.zacceptance=(float(paramvals[7]),zaccept_unit) 
    180                 output.vars=varheader 
     156                output.vars = varheader 
    181157 
    182158                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/sasgui/guiframe/dataFitting.py

    r345e7e4 ra9f579c  
    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 = [] 
    … …  
    6871        # First, check the data compatibility 
    6972        dy, dy_other = self._validity_check(other) 
    70         result = Data1D(x=[], y=[], dx=None, dy=None) 
     73        result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=None) 
    7174        result.clone_without_data(length=len(self.x), clone=self) 
    7275        result.copy_from_datainfo(data1d=self) 
    … …  
    115118        # First, check the data compatibility 
    116119        self._validity_check_union(other) 
    117         result = Data1D(x=[], y=[], dx=None, dy=None) 
     120        result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=None) 
    118121        tot_length = len(self.x) + len(other.x) 
    119122        result = self.clone_without_data(length=tot_length, clone=result) 
     123        if self.dlam == None or other.dlam is None: 
     124            result.dlam = None 
     125        else: 
     126            result.dlam = numpy.zeros(tot_length) 
    120127        if self.dy == None or other.dy is None: 
    121128            result.dy = None 
    … …  
    141148        result.y = numpy.append(self.y, other.y) 
    142149        result.y = result.y[ind] 
     150        result.lam = numpy.append(self.lam, other.lam) 
     151        result.lam = result.lam[ind] 
     152        if result.dlam != None: 
     153            result.dlam = numpy.append(self.dlam, other.dlam) ^ M 
     154            result.dlam = result.dlam[ind] 
    143155        if result.dy != None: 
    144156            result.dy = numpy.append(self.dy, other.dy) 
    … …  
    260272        # First, check the data compatibility 
    261273        self._validity_check_union(other) 
    262         result = Data1D(x=[], y=[], dx=None, dy=None) 
     274        result = Data1D(x=[], y=[], lam=[], dx=None, dy=None, dlam=[]) 
    263275        tot_length = len(self.x)+len(other.x) 
    264276        result.clone_without_data(length=tot_length, clone=self) 
     277        if self.dlam == None or other.dlam is None: 
     278            result.dlam = None 
     279        else: 
     280            result.dlam = numpy.zeros(tot_length) 
    265281        if self.dy == None or other.dy is None: 
    266282            result.dy = None 
    … …  
    285301        result.y = numpy.append(self.y, other.y) 
    286302        result.y = result.y[ind] 
     303        result.lam = numpy.append(self.lam, other.lam) 
     304        result.lam = result.lam[ind] 
    287305        if result.dy != None: 
    288306            result.dy = numpy.append(self.dy, other.dy) 

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

    r345e7e4 ra9f579c  
    6262        if issubclass(Data2D, data.__class__): 
    6363            new_plot = Data2D(image=None, err_image=None)  
    64         else:  
    65             new_plot = Data1D(x=[], y=[], dx=None, dy=None) 
    66             
     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??? 
     68 
    6769        new_plot.copy_from_datainfo(data) 
    6870        data.clone_without_data(clone=new_plot) 

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

    r505706a ra9f579c  
    142142        self.theory_qmin_x = None 
    143143        self.theory_qmax_x = None 
     144        self.cb1 = None # TODO: remove? 
    144145        self.btEditMask = None 
    145146        self.btFit = None 

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