Changeset 46f798f in sasview for src/sas/sascalc


Ignore:
Timestamp:
Feb 28, 2017 12:05:36 PM (8 years ago)
Author:
GitHub <noreply@…>
Children:
13043af, 0d64713
Parents:
587ce8c (diff), c221349 (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:
Jeff Krzywon <krzywon@…> (02/28/17 12:05:36)
git-committer:
GitHub <noreply@…> (02/28/17 12:05:36)
Message:

Merge pull request #31 from SasView?/sesans41

Sesans integration into sasview.

Location:
src/sas/sascalc
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • 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 rc221349  
    261261                # I and Q - 1D data 
    262262                elif tagname == 'I' and isinstance(self.current_dataset, plottable_1D): 
    263                     self.current_dataset.yaxis("Intensity", unit) 
     263                    unit_list = unit.split("|") 
     264                    if len(unit_list) > 1: 
     265                        self.current_dataset.yaxis(unit_list[0].strip(), 
     266                                                   unit_list[1].strip()) 
     267                    else: 
     268                        self.current_dataset.yaxis("Intensity", unit) 
    264269                    self.current_dataset.y = np.append(self.current_dataset.y, data_point) 
    265270                elif tagname == 'Idev' and isinstance(self.current_dataset, plottable_1D): 
    266271                    self.current_dataset.dy = np.append(self.current_dataset.dy, data_point) 
    267272                elif tagname == 'Q': 
    268                     self.current_dataset.xaxis("Q", unit) 
     273                    unit_list = unit.split("|") 
     274                    if len(unit_list) > 1: 
     275                        self.current_dataset.xaxis(unit_list[0].strip(), 
     276                                                   unit_list[1].strip()) 
     277                    else: 
     278                        self.current_dataset.xaxis("Q", unit) 
    269279                    self.current_dataset.x = np.append(self.current_dataset.x, data_point) 
    270280                elif tagname == 'Qdev': 
    … …  
    278288                elif tagname == 'Shadowfactor': 
    279289                    pass 
     290                elif tagname == 'Sesans': 
     291                    self.current_datainfo.isSesans = bool(data_point) 
     292                elif tagname == 'zacceptance': 
     293                    self.current_datainfo.sample.zacceptance = (data_point, unit) 
    280294 
    281295                # I and Qx, Qy - 2D data 
    … …  
    10201034            node.append(point) 
    10211035            self.write_node(point, "Q", datainfo.x[i], 
    1022                             {'unit': datainfo.x_unit}) 
     1036                            {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10231037            if len(datainfo.y) >= i: 
    10241038                self.write_node(point, "I", datainfo.y[i], 
    1025                                 {'unit': datainfo.y_unit}) 
     1039                                {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
    10261040            if datainfo.dy is not None and len(datainfo.dy) > i: 
    10271041                self.write_node(point, "Idev", datainfo.dy[i], 
    1028                                 {'unit': datainfo.y_unit}) 
     1042                                {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
    10291043            if datainfo.dx is not None and len(datainfo.dx) > i: 
    10301044                self.write_node(point, "Qdev", datainfo.dx[i], 
    1031                                 {'unit': datainfo.x_unit}) 
     1045                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10321046            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    10331047                self.write_node(point, "dQw", datainfo.dxw[i], 
    1034                                 {'unit': datainfo.x_unit}) 
     1048                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10351049            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    10361050                self.write_node(point, "dQl", datainfo.dxl[i], 
    1037                                 {'unit': datainfo.x_unit}) 
     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 
    10381059 
    10391060    def _write_data_2d(self, datainfo, entry_node): 

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

    r9525358 r7caf3e5  
    88import numpy 
    99import os 
    10 from sas.sascalc.dataloader.data_info import SESANSData1D 
     10from sas.sascalc.dataloader.data_info import Data1D 
    1111 
    1212# Check whether we have a converter available 
    … …  
    5959                    raise  RuntimeError, "sesans_reader: cannot open %s" % path 
    6060                buff = input_f.read() 
    61 #                print buff 
    6261                lines = buff.splitlines() 
    63 #                print lines 
    64                 #Jae could not find python universal line spliter: 
    65                 #keep the below for now 
    66                 # some ascii data has \r line separator, 
    67                 # try it when the data is on only one long line 
    68 #                if len(lines) < 2 : 
    69 #                    lines = buff.split('\r') 
    70                   
    7162                x  = numpy.zeros(0) 
    7263                y  = numpy.zeros(0) 
    … …  
    8374                tdlam = numpy.zeros(0) 
    8475                tdx = numpy.zeros(0) 
    85 #                print "all good" 
    86                 output = SESANSData1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam) 
    87 #                print output                 
     76                output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True) 
    8877                self.filename = output.filename = basename 
    8978 
    90 #                #Initialize counters for data lines and header lines. 
    91 #                is_data = False  # Has more than 5 lines 
    92 #                # More than "5" lines of data is considered as actual 
    93 #                # data unless that is the only data 
    94 #                mum_data_lines = 5 
    95 #                # To count # of current data candidate lines 
    96 #                i = -1 
    97 #                # To count total # of previous data candidate lines 
    98 #                i1 = -1 
    99 #                # To count # of header lines 
    100 #                j = -1 
    101 #                # Helps to count # of header lines 
    102 #                j1 = -1 
    103 #                #minimum required number of columns of data; ( <= 4). 
    104 #                lentoks = 2 
    10579                paramnames=[] 
    10680                paramvals=[] 
    … …  
    11185                Pvals=[] 
    11286                dPvals=[] 
    113 #                print x 
    114 #                print zvals 
     87 
    11588                for line in lines: 
    11689                    # Initial try for CSV (split on ,) 
    … …  
    12295                    if len(toks)>5: 
    12396                        zvals.append(toks[0]) 
    124                         dzvals.append(toks[1]) 
    125                         lamvals.append(toks[2]) 
    126                         dlamvals.append(toks[3]) 
    127                         Pvals.append(toks[4]) 
    128                         dPvals.append(toks[5]) 
     97                        dzvals.append(toks[3]) 
     98                        lamvals.append(toks[4]) 
     99                        dlamvals.append(toks[5]) 
     100                        Pvals.append(toks[1]) 
     101                        dPvals.append(toks[2]) 
    129102                    else: 
    130103                        continue 
    … …  
    140113                default_z_unit = "A" 
    141114                data_conv_P = None 
    142                 default_p_unit = " " 
     115                default_p_unit = " " # Adjust unit for axis (L^-3) 
    143116                lam_unit = lam_header[1].replace("[","").replace("]","") 
     117                if lam_unit == 'AA': 
     118                    lam_unit = 'A' 
    144119                varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]] 
    145120                valrange=range(1, len(zvals)) 
    … …  
    161136                output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit) 
    162137                output.y = y 
     138                output.y_unit = r'\AA^{-2} cm^{-1}'  # output y_unit added 
    163139                output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit) 
    164140                output.dy = dy 
    165141                output.lam, output.lam_unit = self._unit_conversion(lam, lam_unit, default_z_unit) 
    166142                output.dlam, output.dlam_unit = self._unit_conversion(dlam, lam_unit, default_z_unit) 
     143                 
     144                output.xaxis(r"\rm{z}", output.x_unit) 
     145                output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", output.y_unit)  # Adjust label to ln P/(lam^2 t), remove lam column refs 
    167146 
    168                 output.xaxis(r"\rm{z}", output.x_unit) 
    169                 output.yaxis(r"\rm{P/P0}", output.y_unit) 
    170147                # Store loading process information 
    171148                output.meta_data['loader'] = self.type_name 
    172                 output.sample.thickness = float(paramvals[6]) 
     149                #output.sample.thickness = float(paramvals[6]) 
    173150                output.sample.name = paramvals[1] 
    174151                output.sample.ID = paramvals[0] 
    175152                zaccept_unit_split = paramnames[7].split("[") 
    176153                zaccept_unit = zaccept_unit_split[1].replace("]","") 
    177                 if zaccept_unit.strip() == r'\AA^-1': 
     154                if zaccept_unit.strip() == r'\AA^-1' or zaccept_unit.strip() == r'\A^-1': 
    178155                    zaccept_unit = "1/A" 
    179156                output.sample.zacceptance=(float(paramvals[7]),zaccept_unit) 
    180                 output.vars=varheader 
     157                output.vars = varheader 
    181158 
    182159                if len(output.x) < 1: 

  • src/sas/sascalc/fit/AbstractFitEngine.py

    rd3911e3 ra9f579c  
    131131        a way to get residuals from data. 
    132132    """ 
    133     def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None): 
     133    def __init__(self, x, y, dx=None, dy=None, smearer=None, data=None, lam=None, dlam=None): 
    134134        """ 
    135135            :param smearer: is an object of class QSmearer or SlitSmearer 
    … …  
    152152                 
    153153        """ 
    154         Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy) 
     154        Data1D.__init__(self, x=x, y=y, dx=dx, dy=dy, lam=lam, dlam=dlam) 
    155155        self.num_points = len(x) 
    156156        self.sas_data = data 
Note: See TracChangeset for help on using the changeset viewer.