Changeset 0d64713 in sasview for src/sas/sascalc/dataloader


Ignore:
Timestamp:
Feb 28, 2017 1:17:19 PM (8 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"

Location:
src/sas/sascalc/dataloader
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • 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: 
Note: See TracChangeset for help on using the changeset viewer.