Changeset f2940c4 in sasview for src/sas/sascalc


Ignore:
Timestamp:
Apr 4, 2017 1:10:30 PM (8 years ago)
Author:
Ricardo Ferraz Leal <ricleal@…>
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:
01febaf
Parents:
9c0f3c17 (diff), dd11014 (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 into logger

Location:
src/sas/sascalc
Files:
13 edited

Legend:

Unmodified
Added
Removed

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

    red2276f rdd11014  
    1414#TODO: copy the meta data from the 2D object to the resulting 1D object 
    1515import math 
    16 import numpy as np 
     16import numpy 
    1717 
    1818#from data_info import plottable_2D 
    … …  
    8282    if data2d.data is None or data2d.x_bins is None or data2d.y_bins is None: 
    8383        raise ValueError, "Can't convert this data: data=None..." 
    84     new_x = np.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
    85     new_y = np.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
     84    new_x = numpy.tile(data2d.x_bins, (len(data2d.y_bins), 1)) 
     85    new_y = numpy.tile(data2d.y_bins, (len(data2d.x_bins), 1)) 
    8686    new_y = new_y.swapaxes(0, 1) 
    8787 
    … …  
    8989    qx_data = new_x.flatten() 
    9090    qy_data = new_y.flatten() 
    91     q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
    92     if data2d.err_data == None or np.any(data2d.err_data <= 0): 
    93         new_err_data = np.sqrt(np.abs(new_data)) 
    94  
     91    q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
     92    if data2d.err_data is None or numpy.any(data2d.err_data <= 0): 
     93        new_err_data = numpy.sqrt(numpy.abs(new_data)) 
    9594    else: 
    9695        new_err_data = data2d.err_data.flatten() 
    97     mask = np.ones(len(new_data), dtype=bool) 
     96    mask = numpy.ones(len(new_data), dtype=bool) 
    9897 
    9998    #TODO: make sense of the following two lines... 
    … …  
    150149 
    151150        # Get data 
    152         data = data2D.data[np.isfinite(data2D.data)] 
    153         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    154         qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
    155         qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
     151        data = data2D.data[numpy.isfinite(data2D.data)] 
     152        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     153        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
     154        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
    156155 
    157156        # Build array of Q intervals 
    … …  
    171170            raise RuntimeError, "_Slab._avg: unrecognized axis %s" % str(maj) 
    172171 
    173         x = np.zeros(nbins) 
    174         y = np.zeros(nbins) 
    175         err_y = np.zeros(nbins) 
    176         y_counts = np.zeros(nbins) 
     172        x = numpy.zeros(nbins) 
     173        y = numpy.zeros(nbins) 
     174        err_y = numpy.zeros(nbins) 
     175        y_counts = numpy.zeros(nbins) 
    177176 
    178177        # Average pixelsize in q space 
    … …  
    226225        y = y / y_counts 
    227226        x = x / y_counts 
    228         idx = (np.isfinite(y) & np.isfinite(x)) 
     227        idx = (numpy.isfinite(y) & numpy.isfinite(x)) 
    229228 
    230229        if not idx.any(): 
    … …  
    305304            raise RuntimeError, msg 
    306305        # Get data 
    307         data = data2D.data[np.isfinite(data2D.data)] 
    308         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    309         qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
    310         qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
     306        data = data2D.data[numpy.isfinite(data2D.data)] 
     307        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     308        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
     309        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
    311310 
    312311        y = 0.0 
    … …  
    415414        """ 
    416415        # Get data W/ finite values 
    417         data = data2D.data[np.isfinite(data2D.data)] 
    418         q_data = data2D.q_data[np.isfinite(data2D.data)] 
    419         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    420         mask_data = data2D.mask[np.isfinite(data2D.data)] 
     416        data = data2D.data[numpy.isfinite(data2D.data)] 
     417        q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
     418        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     419        mask_data = data2D.mask[numpy.isfinite(data2D.data)] 
    421420 
    422421        dq_data = None 
    … …  
    449448            dq_overlap_y *= dq_overlap_y 
    450449 
    451             dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     450            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    452451            # Final protection of dq 
    453452            if dq_overlap < 0: 
    454453                dq_overlap = y_min 
    455             dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
    456             dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap 
     454            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)] 
     455            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap 
    457456            # def; dqx_data = dq_r dqy_data = dq_phi 
    458457            # Convert dq 2D to 1D here 
    459458            dqx = dqx_data * dqx_data 
    460459            dqy = dqy_data * dqy_data 
    461             dq_data = np.add(dqx, dqy) 
    462             dq_data = np.sqrt(dq_data) 
    463  
    464         #q_data_max = np.max(q_data) 
     460            dq_data = numpy.add(dqx, dqy) 
     461            dq_data = numpy.sqrt(dq_data) 
     462 
     463        #q_data_max = numpy.max(q_data) 
    465464        if len(data2D.q_data) == None: 
    466465            msg = "Circular averaging: invalid q_data: %g" % data2D.q_data 
    … …  
    470469        nbins = int(math.ceil((self.r_max - self.r_min) / self.bin_width)) 
    471470 
    472         x = np.zeros(nbins) 
    473         y = np.zeros(nbins) 
    474         err_y = np.zeros(nbins) 
    475         err_x = np.zeros(nbins) 
    476         y_counts = np.zeros(nbins) 
     471        x = numpy.zeros(nbins) 
     472        y = numpy.zeros(nbins) 
     473        err_y = numpy.zeros(nbins) 
     474        err_x = numpy.zeros(nbins) 
     475        y_counts = numpy.zeros(nbins) 
    477476 
    478477        for npt in range(len(data)): 
    … …  
    528527 
    529528        err_y = err_y / y_counts 
    530         err_y[err_y == 0] = np.average(err_y) 
     529        err_y[err_y == 0] = numpy.average(err_y) 
    531530        y = y / y_counts 
    532531        x = x / y_counts 
    533         idx = (np.isfinite(y)) & (np.isfinite(x)) 
     532        idx = (numpy.isfinite(y)) & (numpy.isfinite(x)) 
    534533 
    535534        if err_x != None: 
    … …  
    586585 
    587586        # Get data 
    588         data = data2D.data[np.isfinite(data2D.data)] 
    589         q_data = data2D.q_data[np.isfinite(data2D.data)] 
    590         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    591         qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
    592         qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
     587        data = data2D.data[numpy.isfinite(data2D.data)] 
     588        q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
     589        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     590        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
     591        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
    593592 
    594593        # Set space for 1d outputs 
    595         phi_bins = np.zeros(self.nbins_phi) 
    596         phi_counts = np.zeros(self.nbins_phi) 
    597         phi_values = np.zeros(self.nbins_phi) 
    598         phi_err = np.zeros(self.nbins_phi) 
     594        phi_bins = numpy.zeros(self.nbins_phi) 
     595        phi_counts = numpy.zeros(self.nbins_phi) 
     596        phi_values = numpy.zeros(self.nbins_phi) 
     597        phi_err = numpy.zeros(self.nbins_phi) 
    599598 
    600599        # Shift to apply to calculated phi values in order 
    … …  
    637636            phi_values[i] = 2.0 * math.pi / self.nbins_phi * (1.0 * i) 
    638637 
    639         idx = (np.isfinite(phi_bins)) 
     638        idx = (numpy.isfinite(phi_bins)) 
    640639 
    641640        if not idx.any(): 
    … …  
    770769 
    771770        # Get the all data & info 
    772         data = data2D.data[np.isfinite(data2D.data)] 
    773         q_data = data2D.q_data[np.isfinite(data2D.data)] 
    774         err_data = data2D.err_data[np.isfinite(data2D.data)] 
    775         qx_data = data2D.qx_data[np.isfinite(data2D.data)] 
    776         qy_data = data2D.qy_data[np.isfinite(data2D.data)] 
     771        data = data2D.data[numpy.isfinite(data2D.data)] 
     772        q_data = data2D.q_data[numpy.isfinite(data2D.data)] 
     773        err_data = data2D.err_data[numpy.isfinite(data2D.data)] 
     774        qx_data = data2D.qx_data[numpy.isfinite(data2D.data)] 
     775        qy_data = data2D.qy_data[numpy.isfinite(data2D.data)] 
    777776        dq_data = None 
    778777 
    … …  
    804803            dq_overlap_y *= dq_overlap_y 
    805804 
    806             dq_overlap = np.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
     805            dq_overlap = numpy.sqrt((dq_overlap_x + dq_overlap_y) / 2.0) 
    807806            if dq_overlap < 0: 
    808807                dq_overlap = y_min 
    809             dqx_data = data2D.dqx_data[np.isfinite(data2D.data)] 
    810             dqy_data = data2D.dqy_data[np.isfinite(data2D.data)] - dq_overlap 
     808            dqx_data = data2D.dqx_data[numpy.isfinite(data2D.data)] 
     809            dqy_data = data2D.dqy_data[numpy.isfinite(data2D.data)] - dq_overlap 
    811810            # def; dqx_data = dq_r dqy_data = dq_phi 
    812811            # Convert dq 2D to 1D here 
    813812            dqx = dqx_data * dqx_data 
    814813            dqy = dqy_data * dqy_data 
    815             dq_data = np.add(dqx, dqy) 
    816             dq_data = np.sqrt(dq_data) 
     814            dq_data = numpy.add(dqx, dqy) 
     815            dq_data = numpy.sqrt(dq_data) 
    817816 
    818817        #set space for 1d outputs 
    819         x = np.zeros(self.nbins) 
    820         y = np.zeros(self.nbins) 
    821         y_err = np.zeros(self.nbins) 
    822         x_err = np.zeros(self.nbins) 
    823         y_counts = np.zeros(self.nbins) 
     818        x = numpy.zeros(self.nbins) 
     819        y = numpy.zeros(self.nbins) 
     820        y_err = numpy.zeros(self.nbins) 
     821        x_err = numpy.zeros(self.nbins) 
     822        y_counts = numpy.zeros(self.nbins) 
    824823 
    825824        # Get the min and max into the region: 0 <= phi < 2Pi 
    … …  
    924923                #x[i] = math.sqrt((r_inner * r_inner + r_outer * r_outer) / 2) 
    925924                x[i] = x[i] / y_counts[i] 
    926         y_err[y_err == 0] = np.average(y_err) 
    927         idx = (np.isfinite(y) & np.isfinite(y_err)) 
     925        y_err[y_err == 0] = numpy.average(y_err) 
     926        idx = (numpy.isfinite(y) & numpy.isfinite(y_err)) 
    928927        if x_err != None: 
    929928            d_x = x_err[idx] / y_counts[idx] 
    … …  
    10131012        qx_data = data2D.qx_data 
    10141013        qy_data = data2D.qy_data 
    1015         q_data = np.sqrt(qx_data * qx_data + qy_data * qy_data) 
     1014        q_data = numpy.sqrt(qx_data * qx_data + qy_data * qy_data) 
    10161015 
    10171016        # check whether or not the data point is inside ROI 
    … …  
    11141113 
    11151114        # get phi from data 
    1116         phi_data = np.arctan2(qy_data, qx_data) 
     1115        phi_data = numpy.arctan2(qy_data, qx_data) 
    11171116 
    11181117        # Get the min and max into the region: -pi <= phi < Pi 

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

    red2276f rdd11014  
    1414import os 
    1515 
    16 import numpy as np 
    17 import math 
    18 #import logging 
    19  
    2016from sas.sascalc.dataloader.data_info import Data2D 
    2117from sas.sascalc.dataloader.data_info import Detector 
    2218from sas.sascalc.dataloader.manipulations import reader2D_converter 
     19import numpy as np 
    2320 
    2421# Look for unit converter 
    … …  
    6562            data_conv_i(1.0, output.I_unit) 
    6663 
    67         for line in lines: 
    68              
    69             # Find setup info line 
    70             if isInfo: 
    71                 isInfo = False 
    72                 line_toks = line.split() 
    73                 # Wavelength in Angstrom 
    74                 try: 
    75                     wavelength = float(line_toks[1]) 
    76                 except: 
    77                     msg = "IgorReader: can't read this file, missing wavelength" 
    78                     raise ValueError, msg 
    79                  
    80             #Find # of bins in a row assuming the detector is square. 
    81             if dataStarted == True: 
    82                 try: 
    83                     value = float(line) 
    84                 except: 
    85                     # Found a non-float entry, skip it 
    86                     continue 
    87                  
    88                 # Get total bin number 
    89                  
    90             i_tot_row += 1 
    91         i_tot_row = math.ceil(math.sqrt(i_tot_row)) - 1 
    92         #print "i_tot", i_tot_row 
    93         size_x = i_tot_row  # 192#128 
    94         size_y = i_tot_row  # 192#128 
    95         output.data = np.zeros([size_x, size_y]) 
    96         output.err_data = np.zeros([size_x, size_y]) 
    97    
    9864        data_row = 0 
    9965        wavelength = distance = center_x = center_y = None 

  • 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 r463e7ffc  
    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 
    … …  
    244247                pass 
    245248        import logging 
    246         logging.error(traceback.format_exc()) 
     249        logger.error(traceback.format_exc()) 
    247250        #print 'CalcThread exception', 
    248251 

  • 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

    r8434365 r463e7ffc  
    3333import xml.dom.minidom 
    3434from xml.dom.minidom import parseString 
     35 
     36logger = logging.getLogger(__name__) 
    3537 
    3638PREPROCESS = "xmlpreprocess" 
    … …  
    14711473                            self.errors.add(err_mess) 
    14721474                            if optional: 
    1473                                 logging.info(err_mess) 
     1475                                logger.info(err_mess) 
    14741476                            else: 
    14751477                                raise ValueError, err_mess 
    … …  
    14801482                        self.errors.add(err_mess) 
    14811483                        if optional: 
    1482                             logging.info(err_mess) 
     1484                            logger.info(err_mess) 
    14831485                        else: 
    14841486                            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 
Note: See TracChangeset for help on using the changeset viewer.