Changeset 4d465e3 in sasview for src/sas/sascalc


Ignore:
Timestamp:
Apr 9, 2017 4:03:36 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:
a79ab31
Parents:
aa45dcd (diff), ec65dc81 (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/sascalc
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/realspace/VolumeCanvas.py

    rd85c194 r959eb01  
    303303        self.shapecount += 1 
    304304 
    305         #model changed, need to recalculate P(r) 
     305        # model changed, need to recalculate P(r) 
    306306        self._model_changed() 
    307307 
    … …  
    328328            id = "shape"+str(self.shapecount) 
    329329  
    330         #shapeDesc = ShapeDescriptor(shape.lower()) 
     330        # shapeDesc = ShapeDescriptor(shape.lower()) 
    331331        if shape.lower() in shape_dict: 
    332332            shapeDesc = shape_dict[shape.lower()]() 
    … …  
    335335            shapeDesc = PDBDescriptor(shape) 
    336336        else: 
    337             raise ValueError, "VolumeCanvas.add: Unknown shape %s" % shape 
     337            raise ValueError("VolumeCanvas.add: Unknown shape %s" % shape) 
    338338         
    339339        return self.addObject(shapeDesc, id) 
    … …  
    345345        """ 
    346346 
    347         if self.shapes.has_key(id): 
     347        if id in self.shapes: 
    348348            del self.shapes[id] 
    349349        else: 
    350             raise KeyError, "VolumeCanvas.delete: could not find shape ID" 
    351  
    352         #model changed, need to recalculate P(r) 
     350            raise KeyError("VolumeCanvas.delete: could not find shape ID") 
     351 
     352        # model changed, need to recalculate P(r) 
    353353        self._model_changed() 
    354354 
    … …  
    379379        # If a shape identifier was given, look the shape up 
    380380        # in the dictionary 
    381         if len(toks)>1: 
    382             if toks[0] in self.shapes.keys(): 
     381        if len(toks): 
     382            if toks[0] in self.shapes: 
    383383                # The shape was found, now look for the parameter 
    384384                if toks[1] in self.shapes[toks[0]].params: 
    … …  
    387387                    self._model_changed() 
    388388                else: 
    389                     raise ValueError, "Could not find parameter %s" % name 
     389                    raise ValueError("Could not find parameter %s" % name) 
    390390            else: 
    391                 raise ValueError, "Could not find shape %s" % toks[0] 
     391                raise ValueError("Could not find shape %s" % toks[0]) 
    392392         
    393393        else: 
    … …  
    410410        if len(toks) == 1: 
    411411            try: 
    412                 self.params.has_key(toks[0]) 
     412                value = self.params[toks[0]] 
    413413            except KeyError: 
    414                 raise ValueError, \ 
    415                     "VolumeCanvas.getParam: Could not find %s" % name 
    416  
    417             value = self.params[toks[0]] 
     414                raise ValueError("VolumeCanvas.getParam: Could not find" 
     415                                 " %s" % name) 
    418416            if isinstance(value, ShapeDescriptor): 
    419                 raise ValueError, \ 
    420                     "VolumeCanvas.getParam: Cannot get parameter value."  
     417                raise ValueError("VolumeCanvas.getParam: Cannot get parameter" 
     418                                 " value.") 
    421419            else: 
    422420                return value 
    … …  
    424422        elif len(toks) == 2: 
    425423            try: 
    426                 self.shapes.has_key(toks[0]) 
     424                shapeinstance = self.shapes[toks[0]] 
    427425            except KeyError: 
    428                 raise ValueError, \ 
    429                     "VolumeCanvas.getParam: Could not find %s" % name 
    430  
    431             shapeinstance = self.shapes[toks[0]] 
    432  
    433             try: 
    434                 shapeinstance.params.has_key(toks[1]) 
    435             except KeyError: 
    436                 raise ValueError, \ 
    437                     "VolumeCanvas.getParam: Could not find %s" % name 
     426                raise ValueError("VolumeCanvas.getParam: Could not find " 
     427                                 "%s" % name) 
     428 
     429            if not toks[1] in shapeinstance.params: 
     430                raise ValueError("VolumeCanvas.getParam: Could not find " 
     431                                 "%s" % name) 
    438432 
    439433            return shapeinstance.params[toks[1]] 
    440434 
    441435        else: 
    442             raise ValueError, \ 
    443                 "VolumeCanvas.getParam: Could not find %s" % name 
    444              
    445     def getParamList(self, shapeid = None): 
     436            raise ValueError("VolumeCanvas.getParam: Could not find %s" % name) 
     437             
     438    def getParamList(self, shapeid=None): 
    446439        """ 
    447440               return a full list of all available parameters from  
    … …  
    455448 
    456449        param_list = [] 
    457         if shapeid == None:         
    458             for key1 in self.params.keys(): 
     450        if shapeid is None: 
     451            for key1 in self.params: 
    459452                #value1 = self.params[key1] 
    460453                param_list.append(key1) 
    461             for key2 in self.shapes.keys(): 
     454            for key2 in self.shapes: 
    462455                value2 = self.shapes[key2] 
    463456                header = key2 + '.' 
    464                 for key3 in value2.params.keys():    
     457                for key3 in value2.params: 
    465458                    fullname = header + key3                  
    466459                    param_list.append(fullname) 
    467460      
    468461        else: 
    469             try: 
    470                 self.shapes.has_key(shapeid) 
    471             except KeyError: 
    472                 raise ValueError, \ 
    473                     "VolumeCanvas: getParamList: Could not find %s" % shapeid 
     462            if not shapeid in self.shapes: 
     463                raise ValueError("VolumeCanvas: getParamList: Could not find " 
     464                                 "%s" % shapeid) 
     465 
    474466            header = shapeid + '.' 
    475             param_list = self.shapes[shapeid].params.keys()   
    476             for i in range(len(param_list)): 
    477                 param_list[i] = header + param_list[i] 
    478  
     467            param_list = [header + param for param in self.shapes[shapeid].params] 
    479468        return param_list 
    480469 
    … …  
    490479            @param shapeDesc: shape description 
    491480        """ 
    492         #Create the object model 
     481        # Create the object model 
    493482        shapeDesc.create() 
    494483                     
    … …  
    605594        # type we recognize 
    606595        else: 
    607             raise ValueError, "run(q): bad type for q" 
     596            raise ValueError("run(q): bad type for q") 
    608597     
    609598    def runXY(self, q = 0): 
    … …  
    625614        # type we recognize 
    626615        else: 
    627             raise ValueError, "runXY(q): bad type for q" 
     616            raise ValueError("runXY(q): bad type for q") 
    628617     
    629618    def _create_modelObject(self): 

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