Changeset 3c903ea in sasview for src/sas/sascalc


Ignore:
Timestamp:
Apr 6, 2017 4:36:51 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:
d01b55c
Parents:
d3bce8c (diff), 5e2f36c (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:
15 edited

Legend:

Unmodified
Added
Removed

  • src/sas/sascalc/calculator/resolution_calculator.py

    r9a5097c r9c0f3c17  
    1515import sys 
    1616import logging 
     17 
     18logger = logging.getLogger(__name__) 
    1719 
    1820#Plank's constant in cgs unit 
    … …  
    10061008            detector_offset = self.sample2detector_distance[1] 
    10071009        except: 
    1008             logging.error(sys.exc_value) 
     1010            logger.error(sys.exc_value) 
    10091011 
    10101012        # detector size in [no of pix_x,no of pix_y] 
    … …  
    10931095            output.qy_data = qy_value 
    10941096        except: 
    1095             logging.error(sys.exc_value) 
     1097            logger.error(sys.exc_value) 
    10961098 
    10971099        return output 

  • src/sas/sascalc/calculator/sas_gen.py

    r9a5097c r9c0f3c17  
    1212import sys 
    1313import logging 
     14 
     15logger = logging.getLogger(__name__) 
    1416 
    1517MFACTOR_AM = 2.853E-12 
    … …  
    285287                mask = (x_dir2 + y_dir2 + z_dir2) <= 1.0 
    286288            except: 
    287                 logging.error(sys.exc_value) 
     289                logger.error(sys.exc_value) 
    288290        self.output = MagSLD(self.pos_x[mask], self.pos_y[mask], 
    289291                             self.pos_z[mask], self.sld_n[mask], 
    … …  
    394396                except: 
    395397                    # Skip non-data lines 
    396                     logging.error(sys.exc_value) 
     398                    logger.error(sys.exc_value) 
    397399                #Reading Header; Segment count ignored 
    398400                s_line = line.split(":", 1) 
    … …  
    589591                        z_lines.append(z_line) 
    590592                except: 
    591                     logging.error(sys.exc_value) 
     593                    logger.error(sys.exc_value) 
    592594 
    593595            output = MagSLD(pos_x, pos_y, pos_z, sld_n, sld_mx, sld_my, sld_mz) 
    … …  
    683685                    except: 
    684686                        # Skip non-data lines 
    685                         logging.error(sys.exc_value) 
     687                        logger.error(sys.exc_value) 
    686688            output = MagSLD(pos_x, pos_y, pos_z, sld_n, 
    687689                            sld_mx, sld_my, sld_mz) 

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

    r934ce649 r64ca561  
    88import traceback 
    99import sys 
     10import logging 
    1011 
    1112if sys.platform.count("darwin") > 0: 
    … …  
    2122    from time import clock 
    2223    from time import sleep 
     24 
     25logger = logging.getLogger(__name__) 
    2326 
    2427 
    … …  
    243246            except Exception: 
    244247                pass 
    245         import logging 
    246         logging.error(traceback.format_exc()) 
     248        logger.error(traceback.format_exc()) 
    247249        #print 'CalcThread exception', 
    248250 

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

    rb699768 r463e7ffc  
    3232from readers import cansas_reader 
    3333 
     34logger = logging.getLogger(__name__) 
     35 
    3436class Registry(ExtensionRegistry): 
    3537    """ 
    … …  
    99101            msg = "DataLoader couldn't locate DataLoader plugin folder." 
    100102            msg += """ "%s" does not exist""" % dir 
    101             logging.warning(msg) 
     103            logger.warning(msg) 
    102104            return readers_found 
    103105 
    … …  
    117119                        msg = "Loader: Error importing " 
    118120                        msg += "%s\n  %s" % (item, sys.exc_value) 
    119                         logging.error(msg) 
     121                        logger.error(msg) 
    120122 
    121123                # Process zip files 
    … …  
    139141                                msg = "Loader: Error importing" 
    140142                                msg += " %s\n  %s" % (mfile, sys.exc_value) 
    141                                 logging.error(msg) 
     143                                logger.error(msg) 
    142144 
    143145                    except: 
    144146                        msg = "Loader: Error importing " 
    145147                        msg += " %s\n  %s" % (item, sys.exc_value) 
    146                         logging.error(msg) 
     148                        logger.error(msg) 
    147149 
    148150        return readers_found 
    … …  
    190192                msg = "Loader: Error accessing" 
    191193                msg += " Reader in %s\n  %s" % (module.__name__, sys.exc_value) 
    192                 logging.error(msg) 
     194                logger.error(msg) 
    193195        return reader_found 
    194196 
    … …  
    223225            msg = "Loader: Error accessing Reader " 
    224226            msg += "in %s\n  %s" % (loader.__name__, sys.exc_value) 
    225             logging.error(msg) 
     227            logger.error(msg) 
    226228        return reader_found 
    227229 
    … …  
    268270                msg = "Loader: Error accessing Reader" 
    269271                msg += " in %s\n  %s" % (module.__name__, sys.exc_value) 
    270                 logging.error(msg) 
     272                logger.error(msg) 
    271273        return reader_found 
    272274 

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

    re5c09cf r463e7ffc  
    1818import logging 
    1919import json 
     20 
     21logger = logging.getLogger(__name__) 
    2022 
    2123FILE_NAME = 'defaults.json' 
    … …  
    6769                    msg = "read_associations: skipping association" 
    6870                    msg += " for %s\n  %s" % (ext.lower(), sys.exc_value) 
    69                     logging.error(msg) 
     71                    logger.error(msg) 
    7072    else: 
    7173        print "Could not find reader association settings\n  %s [%s]" % (__file__, os.getcwd()) 
    … …  
    8183    :param registry_function: function to be called to register each reader 
    8284    """ 
    83     logging.info("register_readers is now obsolete: use read_associations()") 
     85    logger.info("register_readers is now obsolete: use read_associations()") 
    8486    import abs_reader 
    8587    import ascii_reader 

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

    r747334d r3c903ea  
    3333import xml.dom.minidom 
    3434from xml.dom.minidom import parseString 
     35 
     36logger = logging.getLogger(__name__) 
    3537 
    3638PREPROCESS = "xmlpreprocess" 
    … …  
    14751477                            self.errors.add(err_mess) 
    14761478                            if optional: 
    1477                                 logging.info(err_mess) 
     1479                                logger.info(err_mess) 
    14781480                            else: 
    14791481                                raise ValueError, err_mess 
    … …  
    14841486                        self.errors.add(err_mess) 
    14851487                        if optional: 
    1486                             logging.info(err_mess) 
     1488                            logger.info(err_mess) 
    14871489                        else: 
    14881490                            raise ValueError, err_mess 

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

    r9a5097c r9c0f3c17  
    1919from sas.sascalc.dataloader.data_info import Data2D, Detector 
    2020from sas.sascalc.dataloader.manipulations import reader2D_converter 
     21 
     22logger = logging.getLogger(__name__) 
    2123 
    2224# Look for unit converter 
    … …  
    142144                            error.append(err) 
    143145                        except: 
    144                             logging.info("Skipping line:%s,%s" %(data_str, 
     146                            logger.info("Skipping line:%s,%s" %(data_str, 
    145147                                                                sys.exc_value)) 
    146148             
    … …  
    196198                    msg = "Skipping entry (v1.0):%s,%s" % (str(data[i_pt]), 
    197199                                                           sys.exc_value) 
    198                     logging.info(msg) 
     200                    logger.info(msg) 
    199201                 
    200202                # Get bin number 
    … …  
    271273                raise ValueError, msg 
    272274            else: 
    273                 logging.info("Danse_reader Reading %s \n" % filename) 
     275                logger.info("Danse_reader Reading %s \n" % filename) 
    274276             
    275277            # Store loading process information 

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

    r9a5097c r9c0f3c17  
    1616from sas.sascalc.dataloader.data_info import Data2D 
    1717from sas.sascalc.dataloader.manipulations import reader2D_converter 
    18      
     18 
     19logger = logging.getLogger(__name__) 
     20 
    1921class Reader: 
    2022    """ 
    … …  
    7678                value = float(val) 
    7779            except: 
    78                 logging.error("tiff_reader: had to skip a non-float point") 
     80                logger.error("tiff_reader: had to skip a non-float point") 
    7981                continue 
    8082             

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

    ra235f715 r463e7ffc  
    1818from lxml import etree 
    1919from lxml.builder import E 
     20 
     21logger = logging.getLogger(__name__) 
    2022 
    2123PARSER = etree.ETCompatXMLParser(remove_comments=True, remove_pis=False) 
    … …  
    7173            self.xmlroot = self.xmldoc.getroot() 
    7274        except etree.XMLSyntaxError as xml_error: 
    73             logging.info(xml_error) 
     75            logger.info(xml_error) 
    7476        except Exception: 
    7577            self.xml = None 
    … …  
    8890            self.xmlroot = etree.fromstring(tag_soup) 
    8991        except etree.XMLSyntaxError as xml_error: 
    90             logging.info(xml_error) 
     92            logger.info(xml_error) 
    9193        except Exception: 
    9294            self.xml = None 
    … …  
    102104            self.schemadoc = etree.parse(self.schema, parser=PARSER) 
    103105        except etree.XMLSyntaxError as xml_error: 
    104             logging.info(xml_error) 
     106            logger.info(xml_error) 
    105107        except Exception: 
    106108            self.schema = None 

  • src/sas/sascalc/pr/invertor.py

    r9a5097c r9c0f3c17  
    1818from scipy import optimize 
    1919from sas.sascalc.pr.core.pr_inversion import Cinvertor 
     20 
     21logger = logging.getLogger(__name__) 
    2022 
    2123def help(): 
    … …  
    495497            # We were not able to estimate the errors 
    496498            # Return an empty error matrix 
    497             logging.error(sys.exc_value) 
     499            logger.error(sys.exc_value) 
    498500 
    499501        # Keep a copy of the last output 
    … …  
    541543            # number of terms 
    542544            best_alpha, _, _ = self.estimate_alpha(self.nfunc) 
    543             logging.warning("Invertor.estimate_numterms: %s" % sys.exc_value) 
     545            logger.warning("Invertor.estimate_numterms: %s" % sys.exc_value) 
    544546            return self.nfunc, best_alpha, "Could not estimate number of terms" 
    545547 

  • src/sas/sascalc/pr/num_term.py

    r9a5097c r9c0f3c17  
    55import logging 
    66from sas.sascalc.pr.invertor import Invertor 
     7 
     8logger = logging.getLogger(__name__) 
    79 
    810class NTermEstimator(object): 
    … …  
    180182                data_err = np.append(data_err, err) 
    181183            except: 
    182                 logging.error(sys.exc_value) 
     184                logger.error(sys.exc_value) 
    183185 
    184186    return data_x, data_y, data_err 

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

    r9a5097c r0ac6e11  
    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 
    7376        hankel = SesansTransform(data.x, SElength, zaccept, Rmax) 

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

    r9a5097c r747334d  
    354354    ## SESANS zacceptance 
    355355    zacceptance = None 
     356    yacceptance = None 
    356357 
    357358    def __init__(self): 

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

    rad4632c r747334d  
    135135                             "Sesans": {"storeas": "content"}, 
    136136                             "zacceptance": {"storeas": "float"}, 
     137                             "yacceptance": {"storeas": "float"}, 
    137138                             "<any>" : ANY 
    138139                            } 

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

    r9a5097c r0ac6e11  
    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            dx = data[:, headers.index("SpinEchoLength_error")] 
     74            lam = data[:, headers.index("Wavelength")] 
     75            dlam = data[:, headers.index("Wavelength_error")] 
     76            y = data[:, headers.index("Depolarisation")] 
     77            dy = data[:, headers.index("Depolarisation_error")] 
    8778 
    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 
     79            lam_unit = self._unit_fetch("Wavelength") 
     80            x, x_unit = self._unit_conversion(x, "A", self._unit_fetch("SpinEchoLength")) 
     81            dx, dx_unit = self._unit_conversion( 
     82                dx, lam_unit, 
     83                self._unit_fetch("SpinEchoLength")) 
     84            dlam, dlam_unit = self._unit_conversion( 
     85                dlam, lam_unit, 
     86                self._unit_fetch("Wavelength")) 
     87            y_unit = self._unit_fetch("Depolarisation") 
    10488 
    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])) 
     89            output = Data1D(x=x, y=y, lam=lam, dy=dy, dx=dx, dlam=dlam, 
     90                            isSesans=True) 
    12891 
    129                 x,y,lam,dy,dx,dlam = [ 
    130                     np.asarray(v, 'double') 
    131                    for v in (x,y,lam,dy,dx,dlam) 
    132                 ] 
     92            output.y_unit = y_unit 
     93            output.x_unit = x_unit 
     94            output.source.wavelength_unit = lam_unit 
     95            output.source.wavelength = lam 
     96            self.filename = output.filename = basename 
     97            output.xaxis(r"\rm{z}", x_unit) 
     98            # Adjust label to ln P/(lam^2 t), remove lam column refs 
     99            output.yaxis(r"\rm{ln(P)/(t \lambda^2)}", y_unit) 
     100            # Store loading process information 
     101            output.meta_data['loader'] = self.type_name 
     102            output.sample.name = params["Sample"] 
     103            output.sample.ID = params["DataFileTitle"] 
     104            output.sample.thickness = float( 
     105                self._unit_conversion( 
     106                    params["Thickness"], "cm", self._unit_fetch("Thickness"))[0]) 
    133107 
    134                 input_f.close() 
     108            output.sample.zacceptance = ( 
     109                float(params["Theta_zmax"]), 
     110                self._unit_fetch("Theta_zmax")) 
    135111 
    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 
     112            output.sample.yacceptance = ( 
     113                float(params["Theta_ymax"]), 
     114                self._unit_fetch("Theta_ymax")) 
     115            return output 
    146116 
    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 
     117    @staticmethod 
     118    def _unit_conversion(value, value_unit, default_unit): 
     119        """ 
     120        Performs unit conversion on a measurement. 
    158121 
    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: 
     122        :param value: The magnitude of the measurement 
     123        :param value_unit: a string containing the final desired unit 
     124        :param default_unit: a string containing the units of the original measurement 
     125        :return: The magnitude of the measurement in the new units 
     126        """ 
     127        # (float, string, string) -> float 
     128        if has_converter and value_unit != default_unit: 
    169129            data_conv_q = Converter(value_unit) 
    170130            value = data_conv_q(value, units=default_unit) 
    … …  
    173133            new_unit = value_unit 
    174134        return value, new_unit 
     135 
     136    def _unit_fetch(self, unit): 
     137        return self.params[unit+"_unit"] 
Note: See TracChangeset for help on using the changeset viewer.