Changeset 3c903ea in sasview for src/sas/sascalc/dataloader/readers


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/dataloader/readers
Files:
7 edited

Legend:

Unmodified
Added
Removed

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