Changeset 7caf3e5 in sasview for src/sas/sascalc/dataloader


Ignore:
Timestamp:
Feb 24, 2017 9:39:00 AM (8 years ago)
Author:
GitHub <noreply@…>
Branches:
master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
c221349
Parents:
2ffe241 (diff), cb05bfd (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
git-author:
Paul Kienzle <pkienzle@…> (02/24/17 09:39:00)
git-committer:
GitHub <noreply@…> (02/24/17 09:39:00)
Message:

Merge branch 'master' into sesans41

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

Legend:

Unmodified
Added
Removed

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

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

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

    r345e7e4 r2ffe241  
    2525import numpy 
    2626import math 
    27  
    28 class plottable_sesans1D(object): 
    29     """ 
    30     SESANS is a place holder for 1D SESANS plottables. 
    31  
    32     #TODO: This was directly copied from the plottables_1D. Modified Somewhat. 
    33     #Class has been updated. 
    34     """ 
    35     # The presence of these should be mutually 
    36     # exclusive with the presence of Qdev (dx) 
    37     x = None 
    38     y = None 
    39     lam = None 
    40     dx = None 
    41     dy = None 
    42     dlam = None 
    43     ## Slit smearing length 
    44     dxl = None 
    45     ## Slit smearing width 
    46     dxw = None 
    47  
    48     # Units 
    49     _xaxis = '' 
    50     _xunit = '' 
    51     _yaxis = '' 
    52     _yunit = '' 
    53  
    54     def __init__(self, x, y, lam, dx=None, dy=None, dlam=None): 
    55 #        print "SESANS plottable working" 
    56         self.x = numpy.asarray(x) 
    57         self.y = numpy.asarray(y) 
    58         self.lam = numpy.asarray(lam) 
    59         if dx is not None: 
    60             self.dx = numpy.asarray(dx) 
    61         if dy is not None: 
    62             self.dy = numpy.asarray(dy) 
    63         if dlam is not None: 
    64             self.dlam = numpy.asarray(dlam) 
    65  
    66     def xaxis(self, label, unit): 
    67         """ 
    68         set the x axis label and unit 
    69         """ 
    70         self._xaxis = label 
    71         self._xunit = unit 
    72  
    73     def yaxis(self, label, unit): 
    74         """ 
    75         set the y axis label and unit 
    76         """ 
    77         self._yaxis = label 
    78         self._yunit = unit 
    79  
    8027 
    8128class plottable_1D(object): 
    … …  
    9340    ## Slit smearing width 
    9441    dxw = None 
     42    ## SESANS specific params (wavelengths for spin echo length calculation) 
     43    lam = None 
     44    dlam = None 
    9545 
    9646    # Units 
    … …  
    10050    _yunit = '' 
    10151 
    102     def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None): 
     52    def __init__(self, x, y, dx=None, dy=None, dxl=None, dxw=None, lam=None, dlam=None): 
    10353        self.x = numpy.asarray(x) 
    10454        self.y = numpy.asarray(y) 
    … …  
    11161        if dxw is not None: 
    11262            self.dxw = numpy.asarray(dxw) 
     63        if lam is not None: 
     64            self.lam = numpy.asarray(lam) 
     65        if dlam is not None: 
     66            self.dlam = numpy.asarray(dlam) 
    11367 
    11468    def xaxis(self, label, unit): 
    … …  
    398352    ## Details 
    399353    details = None 
     354    ## SESANS zacceptance 
     355    zacceptance = None 
    400356 
    401357    def __init__(self): 
    … …  
    535491    ## Loading errors 
    536492    errors = None 
     493    ## SESANS data check 
     494    isSesans = None 
     495 
    537496 
    538497    def __init__(self): 
    … …  
    567526        ## Loading errors 
    568527        self.errors = [] 
     528        ## SESANS data check 
     529        self.isSesans = False 
    569530 
    570531    def append_empty_process(self): 
    … …  
    586547        _str += "Title:           %s\n" % self.title 
    587548        _str += "Run:             %s\n" % str(self.run) 
     549        _str += "SESANS:          %s\n" % str(self.isSesans) 
    588550        _str += "Instrument:      %s\n" % str(self.instrument) 
    589551        _str += "%s\n" % str(self.sample) 
    … …  
    736698        return self._perform_union(other) 
    737699 
    738 class SESANSData1D(plottable_sesans1D, DataInfo): 
    739     """ 
    740     SESANS 1D data class 
    741     """ 
    742     x_unit = 'nm' 
    743     y_unit = 'pol' 
    744  
    745     def __init__(self, x=None, y=None, lam=None, dx=None, dy=None, dlam=None): 
     700class Data1D(plottable_1D, DataInfo): 
     701    """ 
     702    1D data class 
     703    """ 
     704    def __init__(self, x=None, y=None, dx=None, dy=None, lam=None, dlam=None, isSesans=None): 
    746705        DataInfo.__init__(self) 
    747         plottable_sesans1D.__init__(self, x, y, lam, dx, dy, dlam) 
     706        plottable_1D.__init__(self, x, y, dx, dy,None, None, lam, dlam) 
     707        self.isSesans = isSesans 
     708        try: 
     709            if self.isSesans: # the data is SESANS 
     710                self.x_unit = 'A' 
     711                self.y_unit = 'pol' 
     712            elif not self.isSesans: # the data is SANS 
     713                self.x_unit = '1/A' 
     714                self.y_unit = '1/cm' 
     715        except: # the data is not recognized/supported, and the user is notified 
     716            raise(TypeError, 'data not recognized, check documentation for supported 1D data formats') 
    748717 
    749718    def __str__(self): 
    … …  
    759728        return _str 
    760729 
    761     def clone_without_data(self, length=0, clone=None): 
    762         """ 
    763         Clone the current object, without copying the data (which 
    764         will be filled out by a subsequent operation). 
    765         The data arrays will be initialized to zero. 
    766  
    767         :param length: length of the data array to be initialized 
    768         :param clone: if provided, the data will be copied to clone 
    769         """ 
    770         from copy import deepcopy 
    771         if clone is None or not issubclass(clone.__class__, Data1D): 
    772             x = numpy.zeros(length) 
    773             dx = numpy.zeros(length) 
    774             y = numpy.zeros(length) 
    775             dy = numpy.zeros(length) 
    776             clone = Data1D(x, y, dx=dx, dy=dy) 
    777  
    778         clone.title = self.title 
    779         clone.run = self.run 
    780         clone.filename = self.filename 
    781         clone.instrument = self.instrument 
    782         clone.notes = deepcopy(self.notes) 
    783         clone.process = deepcopy(self.process) 
    784         clone.detector = deepcopy(self.detector) 
    785         clone.sample = deepcopy(self.sample) 
    786         clone.source = deepcopy(self.source) 
    787         clone.collimation = deepcopy(self.collimation) 
    788         clone.trans_spectrum = deepcopy(self.trans_spectrum) 
    789         clone.meta_data = deepcopy(self.meta_data) 
    790         clone.errors = deepcopy(self.errors) 
    791  
    792         return clone 
    793  
    794 class Data1D(plottable_1D, DataInfo): 
    795     """ 
    796     1D data class 
    797     """ 
    798     x_unit = '1/A' 
    799     y_unit = '1/cm' 
    800  
    801     def __init__(self, x, y, dx=None, dy=None): 
    802         DataInfo.__init__(self) 
    803         plottable_1D.__init__(self, x, y, dx, dy) 
    804  
    805     def __str__(self): 
    806         """ 
    807         Nice printout 
    808         """ 
    809         _str = "%s\n" % DataInfo.__str__(self) 
    810         _str += "Data:\n" 
    811         _str += "   Type:         %s\n" % self.__class__.__name__ 
    812         _str += "   X-axis:       %s\t[%s]\n" % (self._xaxis, self._xunit) 
    813         _str += "   Y-axis:       %s\t[%s]\n" % (self._yaxis, self._yunit) 
    814         _str += "   Length:       %g\n" % len(self.x) 
    815         return _str 
    816  
    817730    def is_slit_smeared(self): 
    818731        """ 
    … …  
    843756            y = numpy.zeros(length) 
    844757            dy = numpy.zeros(length) 
    845             clone = Data1D(x, y, dx=dx, dy=dy) 
     758            lam = numpy.zeros(length) 
     759            dlam = numpy.zeros(length) 
     760            clone = Data1D(x, y, lam=lam, dx=dx, dy=dy, dlam=dlam) 
    846761 
    847762        clone.title = self.title 
    … …  
    1018933    ## Vector of Q-values at the center of each bin in y 
    1019934    y_bins = None 
     935    ## No 2D SESANS data as of yet. Always set it to False 
     936    isSesans = False 
    1020937 
    1021938    def __init__(self, data=None, err_data=None, qx_data=None, 
    1022939                 qy_data=None, q_data=None, mask=None, 
    1023940                 dqx_data=None, dqy_data=None): 
    1024         self.y_bins = [] 
    1025         self.x_bins = [] 
    1026941        DataInfo.__init__(self) 
    1027942        plottable_2D.__init__(self, data, err_data, qx_data, 
    1028943                              qy_data, q_data, mask, dqx_data, dqy_data) 
     944        self.y_bins = [] 
     945        self.x_bins = [] 
     946 
    1029947        if len(self.detector) > 0: 
    1030948            raise RuntimeError, "Data2D: Detector bank already filled at init" 
    … …  
    12651183    final_dataset.xmin = data.xmin 
    12661184    final_dataset.ymin = data.ymin 
     1185    final_dataset.isSesans = datainfo.isSesans 
    12671186    final_dataset.title = datainfo.title 
    12681187    final_dataset.run = datainfo.run 

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

    r250fec92 rad4632c  
    133133               "variable" : None, 
    134134               "children" : {"Idata" : SASDATA_IDATA, 
     135                             "Sesans": {"storeas": "content"}, 
     136                             "zacceptance": {"storeas": "float"}, 
    135137                             "<any>" : ANY 
    136138                            } 

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

    rbcabf4e rb5e9ce26  
    261261                # I and Q - 1D data 
    262262                elif tagname == 'I' and isinstance(self.current_dataset, plottable_1D): 
    263                     self.current_dataset.yaxis("Intensity", unit) 
     263                    unit_list = unit.split(" | ") 
     264                    if len(unit_list) > 1: 
     265                        self.current_dataset.yaxis(unit_list[0], unit_list[1]) 
     266                    else: 
     267                        self.current_dataset.yaxis("Intensity", unit) 
    264268                    self.current_dataset.y = np.append(self.current_dataset.y, data_point) 
    265269                elif tagname == 'Idev' and isinstance(self.current_dataset, plottable_1D): 
    266270                    self.current_dataset.dy = np.append(self.current_dataset.dy, data_point) 
    267271                elif tagname == 'Q': 
    268                     self.current_dataset.xaxis("Q", unit) 
     272                    unit_list = unit.split(" | ") 
     273                    if len(unit_list) > 1: 
     274                        self.current_dataset.xaxis(unit_list[0], unit_list[1]) 
     275                    else: 
     276                        self.current_dataset.xaxis("Q", unit) 
    269277                    self.current_dataset.x = np.append(self.current_dataset.x, data_point) 
    270278                elif tagname == 'Qdev': 
    … …  
    278286                elif tagname == 'Shadowfactor': 
    279287                    pass 
     288                elif tagname == 'Sesans': 
     289                    self.current_datainfo.isSesans = bool(data_point) 
     290                elif tagname == 'zacceptance': 
     291                    self.current_datainfo.sample.zacceptance = (data_point, unit) 
    280292 
    281293                # I and Qx, Qy - 2D data 
    … …  
    10201032            node.append(point) 
    10211033            self.write_node(point, "Q", datainfo.x[i], 
    1022                             {'unit': datainfo.x_unit}) 
     1034                            {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10231035            if len(datainfo.y) >= i: 
    10241036                self.write_node(point, "I", datainfo.y[i], 
    1025                                 {'unit': datainfo.y_unit}) 
     1037                                {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
    10261038            if datainfo.dy is not None and len(datainfo.dy) > i: 
    10271039                self.write_node(point, "Idev", datainfo.dy[i], 
    1028                                 {'unit': datainfo.y_unit}) 
     1040                                {'unit': datainfo._yaxis + " | " + datainfo._yunit}) 
    10291041            if datainfo.dx is not None and len(datainfo.dx) > i: 
    10301042                self.write_node(point, "Qdev", datainfo.dx[i], 
    1031                                 {'unit': datainfo.x_unit}) 
     1043                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10321044            if datainfo.dxw is not None and len(datainfo.dxw) > i: 
    10331045                self.write_node(point, "dQw", datainfo.dxw[i], 
    1034                                 {'unit': datainfo.x_unit}) 
     1046                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
    10351047            if datainfo.dxl is not None and len(datainfo.dxl) > i: 
    10361048                self.write_node(point, "dQl", datainfo.dxl[i], 
    1037                                 {'unit': datainfo.x_unit}) 
     1049                                {'unit': datainfo._xaxis + " | " + datainfo._xunit}) 
     1050        if datainfo.isSesans: 
     1051            sesans = self.create_element("Sesans") 
     1052            sesans.text = str(datainfo.isSesans) 
     1053            node.append(sesans) 
     1054            self.write_node(node, "zacceptance", datainfo.sample.zacceptance[0], 
     1055                             {'unit': datainfo.sample.zacceptance[1]}) 
     1056 
    10381057 
    10391058    def _write_data_2d(self, datainfo, entry_node): 
Note: See TracChangeset for help on using the changeset viewer.