Changeset 24c382a in sasview for src


Ignore:
Timestamp:
Apr 6, 2017 9:20:42 AM (8 years ago)
Author:
Adam Washington <adam.washington@…>
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.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
4c7aa9c
Parents:
cc47336 (diff), ec8886e (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.
Message:

Merge branch 'master' of github.com:SasView/sasview

Location:
src/sas
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r747334d rc44baf97  
    353353    details = None 
    354354    ## SESANS zacceptance 
    355     zacceptance = None 
    356     yacceptance = None 
     355    zacceptance = (0,"") 
     356    yacceptance = (0,"") 
    357357 
    358358    def __init__(self): 

  • src/sas/sasgui/guiframe/media/data_formats_help.rst

    r98c44f3 r76c4469  
    8686 
    8787- Spin echo length (z, in Angstroms) 
    88 - depolarization (:math:`log(P/P_0)/(lambda^2 * thickness)`, in Angstrom^-1 cm^-1) 
     88- depolarization (:math:`log(P/P_0)/(lambda^2 * thickness)`, in Angstrom :sup:`-1` cm :sup:`-1`\ ) 
    8989- depolarization error in the same unit) (measurement error) 
    9090- Spin echo length error (:math:`\Delta`\ z, in Angstroms) (experimental resolution) 

  • src/sas/sasgui/plottools/LineModel.py

    rdd5bf63 rec8886e  
    88function should disappear in a future iteration (see notes in fitDialog) 
    99 
    10                 -PDB   July 10, 2016 
     10PDB   July 10, 2016 
     11 
    1112""" 
    1213 
    … …  
    7071        runXY is when the if statement is true. I however cannot see what that 
    7172        function is for.  It needs to be documented here or removed. 
    72         -PDB 7/10/16  
     73        PDB 7/10/16  
    7374 
    7475        :param x: simple value 
    … …  
    9293        but the only difference between this and run is when the if  
    9394        statement is true. I however cannot see what that function 
    94         is for.  It needs to be documented here or removed. -PDB 7/10/16  
     95        is for.  It needs to be documented here or removed. PDB 7/10/16  
    9596 
    9697        :param x: simple value 

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

    r9a5097c rd01b55c  
    6767    if _found_sesans == True: 
    6868        #Pre-compute the Hankel matrix (H) 
    69         qmax, qunits = data.sample.zacceptance 
    7069        SElength = Converter(data._xunit)(data.x, "A") 
    71         zaccept = Converter(qunits)(qmax, "1/A"), 
     70 
     71        theta_max = Converter("radians")(data.sample.zacceptance)[0] 
     72        q_max = 2 * np.pi / np.max(data.source.wavelength) * np.sin(theta_max) 
     73        zaccept = Converter("1/A")(q_max, "1/" + data.source.wavelength_unit), 
     74 
    7275        Rmax = 10000000 
    73         hankel = SesansTransform(data.x, SElength, zaccept, Rmax) 
     76        hankel = SesansTransform(data.x, SElength, data.source.wavelength, zaccept, Rmax) 
    7477        # Then return the actual transform, as if it were a smearing function 
    7578        return PySmear(hankel, model, offset=0) 

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

    r9a5097c r857cc58  
    11""" 
    22    SESANS reader (based on ASCII reader) 
    3      
     3 
    44    Reader for .ses or .sesans file format 
    5      
    6     Jurrian Bakker  
     5 
     6    Jurrian Bakker 
    77""" 
     8import logging 
    89import numpy as np 
    910import os 
    … …  
    1819_ZERO = 1e-16 
    1920 
     21 
    2022class Reader: 
    2123    """ 
    2224    Class to load sesans files (6 columns). 
    2325    """ 
    24     ## File type 
     26    # File type 
    2527    type_name = "SESANS" 
    26      
    27     ## Wildcards 
     28 
     29    # Wildcards 
    2830    type = ["SESANS files (*.ses)|*.ses", 
    2931            "SESANS files (*..sesans)|*.sesans"] 
    30     ## List of allowed extensions 
     32    # List of allowed extensions 
    3133    ext = ['.ses', '.SES', '.sesans', '.SESANS'] 
    32      
    33     ## Flag to bypass extension check 
     34 
     35    # Flag to bypass extension check 
    3436    allow_all = True 
    35      
     37 
    3638    def read(self, path): 
    37          
    38 #        print "reader triggered" 
    39          
    4039        """ 
    4140        Load data file 
    42          
     41 
    4342        :param path: file path 
    44          
     43 
    4544        :return: SESANSData1D object, or None 
    46          
     45 
    4746        :raise RuntimeError: when the file can't be opened 
    4847        :raise ValueError: when the length of the data vectors are inconsistent 
    … …  
    5150            basename = os.path.basename(path) 
    5251            _, extension = os.path.splitext(basename) 
    53             if self.allow_all or extension.lower() in self.ext: 
    54                 try: 
    55                     # Read in binary mode since GRASP frequently has no-ascii 
    56                     # characters that brakes the open operation 
    57                     input_f = open(path,'rb') 
    58                 except: 
    59                     raise  RuntimeError, "sesans_reader: cannot open %s" % path 
    60                 buff = input_f.read() 
    61                 lines = buff.splitlines() 
    62                 x  = np.zeros(0) 
    63                 y  = np.zeros(0) 
    64                 dy = np.zeros(0) 
    65                 lam  = np.zeros(0) 
    66                 dlam = np.zeros(0) 
    67                 dx = np.zeros(0) 
    68                  
    69                #temp. space to sort data 
    70                 tx  = np.zeros(0) 
    71                 ty  = np.zeros(0) 
    72                 tdy = np.zeros(0) 
    73                 tlam  = np.zeros(0) 
    74                 tdlam = np.zeros(0) 
    75                 tdx = np.zeros(0) 
    76                 output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, isSesans=True) 
    77                 self.filename = output.filename = basename 
     52            if not (self.allow_all or extension.lower() in self.ext): 
     53                raise RuntimeError("{} has an unrecognized file extension".format(path)) 
     54        else: 
     55            raise RunetimeError("{} is not a file".format(path)) 
     56        with open(path, 'r') as input_f: 
     57            # Read in binary mode since GRASP frequently has no-ascii 
     58            # characters that brakes the open operation 
     59            line = input_f.readline() 
     60            params = {} 
     61            while not line.startswith("BEGIN_DATA"): 
     62                terms = line.split() 
     63                if len(terms) >= 2: 
     64                    params[terms[0]] = " ".join(terms[1:]) 
     65                line = input_f.readline() 
     66            self.params = params 
     67            headers = input_f.readline().split() 
    7868 
    79                 paramnames=[] 
    80                 paramvals=[] 
    81                 zvals=[] 
    82                 dzvals=[] 
    83                 lamvals=[] 
    84                 dlamvals=[] 
    85                 Pvals=[] 
    86                 dPvals=[] 
     69            data = np.loadtxt(input_f) 
     70            if data.size < 1: 
     71                raise RuntimeError("{} is empty".format(path)) 
     72            x = data[:, headers.index("SpinEchoLength")] 
     73            if "SpinEchoLength_error" in headers: 
     74                dx = data[:, headers.index("SpinEchoLength_error")] 
     75            else: 
     76                dx = x*0.05 
     77            lam = data[:, headers.index("Wavelength")] 
     78            if "Wavelength_error" in headers: 
     79                dlam = data[:, headers.index("Wavelength_error")] 
     80            else: 
     81                dlam = lam*0.05 
     82            y = data[:, headers.index("Depolarisation")] 
     83            dy = data[:, headers.index("Depolarisation_error")] 
    8784 
    88                 for line in lines: 
    89                     # Initial try for CSV (split on ,) 
    90                     line=line.strip() 
    91                     toks = line.split('\t') 
    92                     if len(toks)==2: 
    93                         paramnames.append(toks[0]) 
    94                         paramvals.append(toks[1]) 
    95                     if len(toks)>5: 
    96                         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]) 
    102                     else: 
    103                         continue 
     85            lam_unit = self._unit_fetch("Wavelength") 
     86            x, x_unit = self._unit_conversion(x, "A", self._unit_fetch("SpinEchoLength")) 
     87            dx, dx_unit = self._unit_conversion( 
     88                dx, lam_unit, 
     89                self._unit_fetch("SpinEchoLength")) 
     90            dlam, dlam_unit = self._unit_conversion( 
     91                dlam, lam_unit, 
     92                self._unit_fetch("Wavelength")) 
     93            y_unit = self._unit_fetch("Depolarisation") 
    10494 
    105                 x=[] 
    106                 y=[] 
    107                 lam=[] 
    108                 dx=[] 
    109                 dy=[] 
    110                 dlam=[] 
    111                 lam_header = lamvals[0].split() 
    112                 data_conv_z = None 
    113                 default_z_unit = "A" 
    114                 data_conv_P = None 
    115                 default_p_unit = " " # Adjust unit for axis (L^-3) 
    116                 lam_unit = lam_header[1].replace("[","").replace("]","") 
    117                 if lam_unit == 'AA': 
    118                     lam_unit = 'A' 
    119                 varheader=[zvals[0],dzvals[0],lamvals[0],dlamvals[0],Pvals[0],dPvals[0]] 
    120                 valrange=range(1, len(zvals)) 
    121                 for i in valrange: 
    122                     x.append(float(zvals[i])) 
    123                     y.append(float(Pvals[i])) 
    124                     lam.append(float(lamvals[i])) 
    125                     dy.append(float(dPvals[i])) 
    126                     dx.append(float(dzvals[i])) 
    127                     dlam.append(float(dlamvals[i])) 
     95            output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, 
     96                            isSesans=True) 
    12897 
    129                 x,y,lam,dy,dx,dlam = [ 
    130                     np.asarray(v, 'double') 
    131                    for v in (x,y,lam,dy,dx,dlam) 
    132                 ] 
     98            output.y_unit = y_unit 
     99            output.x_unit = x_unit 
     100            output.source.wavelength_unit = lam_unit 
     101            output.source.wavelength = lam 
     102            self.filename = output.filename = basename 
     103            output.xaxis(r"\rm{z}", x_unit) 
     104            # Adjust label to ln P/(lam^2 t), remove lam column refs 
     105            output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit) 
     106            # Store loading process information 
     107            output.meta_data['loader'] = self.type_name 
     108            output.sample.name = params["Sample"] 
     109            output.sample.ID = params["DataFileTitle"] 
     110            output.sample.thickness = self._unit_conversion( 
     111                float(params["Thickness"]), "cm", 
     112                self._unit_fetch("Thickness"))[0] 
    133113 
    134                 input_f.close() 
     114            output.sample.zacceptance = ( 
     115                float(params["Theta_zmax"]), 
     116                self._unit_fetch("Theta_zmax")) 
    135117 
    136                 output.x, output.x_unit = self._unit_conversion(x, lam_unit, default_z_unit) 
    137                 output.y = y 
    138                 output.y_unit = r'\AA^{-2} cm^{-1}'  # output y_unit added 
    139                 output.dx, output.dx_unit = self._unit_conversion(dx, lam_unit, default_z_unit) 
    140                 output.dy = dy 
    141                 output.lam, output.lam_unit = self._unit_conversion(lam, lam_unit, default_z_unit) 
    142                 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 
     118            output.sample.yacceptance = ( 
     119                float(params["Theta_ymax"]), 
     120                self._unit_fetch("Theta_ymax")) 
     121            return output 
    146122 
    147                 # Store loading process information 
    148                 output.meta_data['loader'] = self.type_name 
    149                 #output.sample.thickness = float(paramvals[6]) 
    150                 output.sample.name = paramvals[1] 
    151                 output.sample.ID = paramvals[0] 
    152                 zaccept_unit_split = paramnames[7].split("[") 
    153                 zaccept_unit = zaccept_unit_split[1].replace("]","") 
    154                 if zaccept_unit.strip() == r'\AA^-1' or zaccept_unit.strip() == r'\A^-1': 
    155                     zaccept_unit = "1/A" 
    156                 output.sample.zacceptance=(float(paramvals[7]),zaccept_unit) 
    157                 output.vars = varheader 
     123    @staticmethod 
     124    def _unit_conversion(value, value_unit, default_unit): 
     125        """ 
     126        Performs unit conversion on a measurement. 
    158127 
    159                 if len(output.x) < 1: 
    160                     raise RuntimeError, "%s is empty" % path 
    161                 return output 
    162  
    163         else: 
    164             raise RuntimeError, "%s is not a file" % path 
    165         return None 
    166  
    167     def _unit_conversion(self, value, value_unit, default_unit): 
    168         if has_converter == True and value_unit != default_unit: 
    169             data_conv_q = Converter(value_unit) 
    170             value = data_conv_q(value, units=default_unit) 
     128        :param value: The magnitude of the measurement 
     129        :param value_unit: a string containing the final desired unit 
     130        :param default_unit: a string containing the units of the original measurement 
     131        :return: The magnitude of the measurement in the new units 
     132        """ 
     133        # (float, string, string) -> float 
     134        if has_converter and value_unit != default_unit: 
     135            data_conv_q = Converter(default_unit) 
     136            value = data_conv_q(value, units=value_unit) 
    171137            new_unit = default_unit 
    172138        else: 
    173139            new_unit = value_unit 
    174140        return value, new_unit 
     141 
     142    def _unit_fetch(self, unit): 
     143        return self.params[unit+"_unit"] 
Note: See TracChangeset for help on using the changeset viewer.