Changeset b916afa in sasview


Ignore:
Timestamp:
Sep 27, 2017 10:50:34 AM (5 years ago)
Author:
Paul Kienzle <pkienzle@…>
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, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload
Children:
5005ae0, 2b538cd
Parents:
5a81885 (diff), 9be22cd (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 'ticket-853-fit-gui-to-calc' into py3

Files:
1 added
63 edited
1 moved

Legend:

Unmodified
Added
Removed
  • src/sas/sascalc/corfunc/corfunc_calculator.py

    r574adc7 rb916afa  
    124124 
    125125        params, s2 = self._fit_data(q, iq) 
     126        # Extrapolate to 100*Qmax in experimental data 
    126127        qs = np.arange(0, q[-1]*100, (q[1]-q[0])) 
    127128        iqs = s2(qs) 
  • src/sas/sasgui/perspectives/corfunc/media/corfunc_help.rst

    rf80b416e rad476d1  
    99----------- 
    1010 
    11 This performs a correlation function analysis of one-dimensional 
    12 SAXS/SANS data, or generates a model-independent volume fraction 
    13 profile from the SANS from an adsorbed polymer/surfactant layer. 
     11This currently performs correlation function analysis on SAXS/SANS data,  
     12but in the the future is also planned to generate model-independent volume  
     13fraction profiles from the SANS from adsorbed polymer/surfactant layers.  
     14The two types of analyses differ in the mathematical transform that is  
     15applied to the data (Fourier vs Hilbert). However, both functions are  
     16returned in *real space*. 
    1417 
    1518A correlation function may be interpreted in terms of an imaginary rod moving 
    16 through the structure of the material. Γ\ :sub:`1D`\ (R) is the probability that 
    17 a rod of length R moving through the material has equal electron/neutron scattering 
    18 length density at either end. Hence a frequently occurring spacing within a structure 
    19 manifests itself as a peak. 
    20  
    21 A volume fraction profile :math:`\Phi`\ (z) describes how the density of polymer segments/surfactant molecules varies with distance from an (assumed locally flat) interface. 
    22  
    23 Both functions are returned in *real space*. 
    24  
    25 The analysis is performed in 3 stages: 
    26  
    27 *  Extrapolation of the scattering curve to :math:`Q = 0` and 
     19through the structure of the material. Γ(x) is the probability that a rod of  
     20length x has equal electron/neutron scattering length density at either end.  
     21Hence a frequently occurring spacing within a structure will manifest itself  
     22as a peak in Γ(x). *SasView* will return both the one-dimensional ( Γ\ :sub:`1`\ (x) )  
     23and three-dimensional ( Γ\ :sub:`3`\ (x) ) correlation functions, the difference  
     24being that the former is only averaged in the plane of the scattering vector. 
     25 
     26A volume fraction profile :math:`\Phi`\ (z) describes how the density of polymer  
     27segments/surfactant molecules varies with distance, z, normal to an (assumed  
     28locally flat) interface. The form of :math:`\Phi`\ (z) can provide information  
     29about the arrangement of polymer/surfactant molecules at the interface. The width  
     30of the profile provides measures of the layer thickness, and the area under  
     31the profile is related to the amount of material that is adsorbed. 
     32 
     33Both analyses are performed in 3 stages: 
     34 
     35*  Extrapolation of the scattering curve to :math:`Q = 0` and toward  
    2836   :math:`Q = \infty` 
    2937*  Smoothed merging of the two extrapolations into the original data 
    3038*  Fourier / Hilbert Transform of the smoothed data to give the correlation 
    31    function / volume fraction profile, respectively 
    32 *  (Optional) Interpretation of the 1D correlation function based on an ideal 
    33    lamellar morphology 
     39   function or volume fraction profile, respectively 
     40*  (Optional) Interpretation of Γ\ :sub:`1`\ (x) assuming the sample conforms  
     41   to an ideal lamellar morphology 
    3442 
    3543.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 
     44 
    3645 
    3746Extrapolation 
     
    4150................ 
    4251 
    43 The data are extrapolated to Q = 0 by fitting a Guinier model to the data 
    44 points in the low-Q range. 
     52The data are extrapolated to q = 0 by fitting a Guinier function to the data 
     53points in the low-q range. 
    4554 
    4655The equation used is: 
    4756 
    4857.. math:: 
    49     I(Q) = Ae^{Bq^2} 
    50  
    51 The Guinier model assumes that the small angle scattering arises from particles 
    52 and that parameter :math:`B` is related to the radius of gyration of those 
    53 particles. This has dubious applicability to polymer systems. However, the 
    54 correlation function is affected by the Guinier back-extrapolation to the 
    55 greatest extent at large values of R and so only has a 
    56 small effect on the final analysis. 
     58    I(q) = A e^{Bq^2} 
     59 
     60Where the parameter :math:`B` is related to the effective radius-of-gyration of  
     61a spherical object having the same small-angle scattering in this region. 
     62         
     63Note that as q tends to zero this function tends to a limiting value and is  
     64therefore less appropriate for use in systems where the form factor does not  
     65do likewise. However, because of the transform, the correlation functions are  
     66most affected by the Guinier back-extrapolation at *large* values of x where  
     67the impact on any extrapolated parameters will be least significant. 
    5768 
    5869To :math:`Q = \infty` 
    5970..................... 
    6071 
    61 The data are extrapolated to Q = :math:`\infty` by fitting a Porod model to 
    62 the data points in the high-Q range. 
     72The data are extrapolated towards q = :math:`\infty` by fitting a Porod model to 
     73the data points in the high-q range and then computing the extrapolation to 100  
     74times the maximum q value in the experimental dataset. This should be more than  
     75sufficient to ensure that on transformation any truncation artefacts introduced  
     76are at such small values of x that they can be safely ignored. 
    6377 
    6478The equation used is: 
    6579 
    6680.. math:: 
    67     I(Q) = K Q^{-4}e^{-Q^2\sigma^2} + Bg 
    68  
    69 Where :math:`Bg` is the background, :math:`K` is the Porod 
    70 constant, and :math:`\sigma` (which must be > 0) describes the width of the electron or neutron scattering length density profile at the interface between the crystalline and amorphous 
    71 regions as shown below. 
     81    I(q) = K q^{-4}e^{-q^2\sigma^2} + Bg 
     82 
     83Where :math:`Bg` is the background, :math:`K` is the Porod constant, and :math:`\sigma` (which  
     84must be > 0) describes the width of the electron/neutron scattering length density  
     85profile at the interface between the crystalline and amorphous regions as shown below. 
    7286 
    7387.. figure:: fig1.png 
     
    7892--------- 
    7993 
    80 The extrapolated data set consists of the Guinier back-extrapolation from Q~0 
    81 up to the lowest Q value in the original data, then the original scattering data, and the Porod tail-fit beyond this. The joins between the original data and the Guinier/Porod fits are smoothed using the algorithm below to avoid the formation of ripples in the transformed data. 
     94The extrapolated data set consists of the Guinier back-extrapolation from q ~ 0 
     95up to the lowest q value in the original data, then the original scattering data,  
     96and then the Porod tail-fit beyond this. The joins between the original data and  
     97the Guinier/Porod extrapolations are smoothed using the algorithm below to try  
     98and avoid the formation of truncation ripples in the transformed data: 
    8299 
    83100Functions :math:`f(x_i)` and :math:`g(x_i)` where :math:`x_i \in \left\{ 
     
    94111 
    95112 
    96 Transform 
    97 --------- 
     113Transformation 
     114-------------- 
    98115 
    99116Fourier 
    100117....... 
    101118 
    102 If "Fourier" is selected for the transform type, the analysis will perform a 
     119If "Fourier" is selected for the transform type, *SasView* will perform a 
    103120discrete cosine transform on the extrapolated data in order to calculate the 
    104 1D correlation function: 
    105  
    106 .. math:: 
    107     \Gamma _{1D}(R) = \frac{1}{Q^{*}} \int_{0}^{\infty }I(q) q^{2} cos(qR) dq 
    108  
    109 where Q\ :sup:`*` is the Scattering Invariant. 
     1211D correlation function as: 
     122 
     123.. math:: 
     124    \Gamma _{1}(x) = \frac{1}{Q^{*}} \int_{0}^{\infty }I(q) q^{2} cos(qx) dq 
     125 
     126where Q\ :sup:`*` is the Scattering (also called Porod) Invariant. 
    110127 
    111128The following algorithm is applied: 
     
    116133    N-1, N 
    117134 
    118 The 3D correlation function is also calculated: 
    119  
    120 .. math:: 
    121     \Gamma _{3D}(R) = \frac{1}{Q^{*}} \int_{0}^{\infty}I(q) q^{2} 
    122     \frac{sin(qR)}{qR} dq 
     135The 3D correlation function is calculated as: 
     136 
     137.. math:: 
     138    \Gamma _{3}(x) = \frac{1}{Q^{*}} \int_{0}^{\infty}I(q) q^{2} 
     139    \frac{sin(qx)}{qx} dq 
     140 
     141.. note:: It is always advisable to inspect Γ\ :sub:`1`\ (x) and Γ\ :sub:`3`\ (x)  
     142    for artefacts arising from the extrapolation and transformation processes: 
     143         
     144        - do they tend to zero as x tends to :math:`\infty`? 
     145        - do they smoothly curve onto the ordinate at x = 0? (if not check the value  
     146          of :math:`\sigma` is sensible) 
     147        - are there ripples at x values corresponding to (2 :math:`pi` over) the two  
     148          q values at which the extrapolated and experimental data are merged? 
     149        - are there any artefacts at x values corresponding to 2 :math:`pi` / q\ :sub:`max` in  
     150          the experimental data?  
     151        - and lastly, do the significant features/peaks in the correlation functions  
     152          actually correspond to anticpated spacings in the sample?!!! 
     153 
     154Finally, the program calculates the interface distribution function (IDF) g\ :sub:`1`\ (x) as  
     155the discrete cosine transform of: 
     156 
     157.. math:: 
     158    -q^{4} I(q) 
     159 
     160The IDF is proportional to the second derivative of Γ\ :sub:`1`\ (x). 
    123161 
    124162Hilbert 
    125163....... 
    126  
     164         
    127165If "Hilbert" is selected for the transform type, the analysis will perform a 
    128166Hilbert transform on the extrapolated data in order to calculate the Volume 
    129167Fraction Profile. 
    130168 
    131 .. note:: This functionality is not yet implemented in SasView. 
     169.. note:: The Hilbert transform functionality is not yet implemented in SasView. 
    132170 
    133171 
     
    138176.................... 
    139177 
    140 Once the correlation function has been calculated it may be interpreted by clicking the "Compute Parameters" button. 
    141  
    142 The correlation function is interpreted in terms of an ideal lamellar 
    143 morphology, and structural parameters are obtained from it as shown below. 
    144 It should be noted that a small beam size is assumed; ie, no de-smearing is 
    145 performed. 
     178Once the correlation functions have been calculated *SasView* can be asked to  
     179try and interpret Γ\ :sub:`1`\ (x) in terms of an ideal lamellar morphology  
     180as shown below. 
    146181 
    147182.. figure:: fig2.png 
    148183   :align: center 
    149184 
    150 The structural parameters obtained are: 
     185The structural parameters extracted are: 
    151186 
    152187*   Long Period :math:`= L_p` 
     
    160195....................... 
    161196 
    162 SasView does not provide any automatic interpretation of volume fraction profiles in the same way that it does for correlation functions. However, a number of structural parameters are obtainable by other means: 
     197SasView does not provide any automatic interpretation of volume fraction profiles  
     198in the same way that it does for correlation functions. However, a number of  
     199structural parameters are obtainable by other means: 
    163200 
    164201*   Surface Coverage :math:`=\theta` 
     
    175212   :align: center 
    176213 
     214The reader is directed to the references for information on these parameters. 
    177215 
    178216References 
    179217---------- 
    180218 
     219Correlation Function 
     220.................... 
     221 
    181222Strobl, G. R.; Schneider, M. *J. Polym. Sci.* (1980), 18, 1343-1359 
    182223 
     
    189230Baltá Calleja, F. J.; Vonk, C. G. *X-ray Scattering of Synthetic Poylmers*, Elsevier. Amsterdam (1989), 260-270 
    190231 
     232Göschel, U.; Urban, G. *Polymer* (1995), 36, 3633-3639 
     233 
     234Stribeck, N. *X-Ray Scattering of Soft Matter*, Springer. Berlin (2007), 138-161 
     235 
    191236:ref:`FDR` (PDF format) 
     237 
     238Volume Fraction Profile 
     239....................... 
     240 
     241Washington, C.; King, S. M. *J. Phys. Chem.*, (1996), 100, 7603-7609 
     242 
     243Cosgrove, T.; King, S. M.; Griffiths, P. C. *Colloid-Polymer Interactions: From Fundamentals to Practice*, Wiley. New York (1999), 193-204 
     244 
     245King, S. M.; Griffiths, P. C.; Cosgrove, T. *Applications of Neutron Scattering to Soft Condensed Matter*, Gordon & Breach. Amsterdam (2000), 77-105 
     246 
     247King, S.; Griffiths, P.; Hone, J.; Cosgrove, T. *Macromol. Symp.* (2002), 190, 33-42 
    192248 
    193249.. ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ 
     
    198254Upon sending data for correlation function analysis, it will be plotted (minus 
    199255the background value), along with a *red* bar indicating the *upper end of the 
    200 low-Q range* (used for back-extrapolation), and 2 *purple* bars indicating the range to be used for forward-extrapolation. These bars may be moved my clicking and 
    201 dragging, or by entering appropriate values in the Q range input boxes. 
     256low-Q range* (used for Guinier back-extrapolation), and 2 *purple* bars indicating  
     257the range to be used for Porod forward-extrapolation. These bars may be moved by  
     258grabbing and dragging, or by entering appropriate values in the Q range input boxes. 
    202259 
    203260.. figure:: tutorial1.png 
    204261   :align: center 
    205262 
    206 Once the Q ranges have been set, click the "Calculate" button to determine the background level. Alternatively, enter your own value into the field. If the box turns yellow this indicates that background subtraction has resulted in some negative intensities. 
    207  
    208 Click the "Extrapolate" button to extrapolate the data and plot the extrapolation in the same figure. The values of the parameters used for the Guinier and Porod models will also be shown in the "Extrapolation Parameters" section of the window. 
     263Once the Q ranges have been set, click the "Calculate Bg" button to determine the  
     264background level. Alternatively, enter your own value into the box. If the box turns  
     265yellow this indicates that background subtraction has created some negative intensities. 
     266 
     267Now click the "Extrapolate" button to extrapolate the data. The graph window will update  
     268to show the extrapolated data, and the values of the parameters used for the Guinier and  
     269Porod extrapolations will appear in the "Extrapolation Parameters" section of the SasView  
     270GUI. 
    209271 
    210272.. figure:: tutorial2.png 
     
    214276buttons: 
    215277 
    216 *   **Fourier** Perform a Fourier Transform to calculate the correlation 
    217     function 
    218 *   **Hilbert** Perform a Hilbert Transform to calculate the volume fraction 
     278*   **Fourier**: to perform a Fourier Transform to calculate the correlation 
     279    functions 
     280*   **Hilbert**: to perform a Hilbert Transform to calculate the volume fraction 
    219281    profile 
    220282 
    221 Click the "Transform" button to perform the selected transform and plot 
    222 the result in a new graph window. 
    223  
    224 If a Fourier Transform was performed, the "Compute Parameters" button can now be clicked to interpret the correlation function as described earlier. 
     283and click the "Transform" button to perform the selected transform and plot 
     284the results. 
    225285 
    226286 .. figure:: tutorial3.png 
    227287    :align: center 
    228288 
     289If a Fourier Transform was performed, the "Compute Parameters" button can now be  
     290clicked to interpret the correlation function as described earlier. The parameters  
     291will appear in the "Output Parameters" section of the SasView GUI. 
     292 
     293 .. figure:: tutorial4.png 
     294    :align: center 
     295 
    229296 
    230297.. note:: 
    231     This help document was last changed by Steve King, 08Oct2016 
     298    This help document was last changed by Steve King, 26Sep2017 
  • build_tools/conda/periodictable/meta.yaml

    r55bde35 r36ca21e  
    11package: 
    22  name: periodictable 
    3   version: !!str 1.4.1 
     3  version: !!str 1.5.0 
    44 
    55source: 
    6   fn: periodictable-1.4.1.tar.gz 
    7   url: https://pypi.python.org/packages/source/p/periodictable/periodictable-1.4.1.tar.gz 
    8   md5: 7246b63cc0b6b1be6e86b6616f9e866e 
     6  fn: periodictable-1.5.0.tar.gz 
     7  url: https://pypi.python.org/packages/source/p/periodictable/periodictable-1.5.0.tar.gz 
     8  md5: f7e0d8199b0fe829868d24a0a734398e 
    99#  patches: 
    1010   # List any patch files here 
  • build_tools/jenkins_rhel6_build.sh

    r243fbc0 r36ca21e  
    2929"$EASY_INSTALL" -d "$WORKSPACE/utils" pyparsing==1.5.5 
    3030"$EASY_INSTALL" -d "$WORKSPACE/utils" bumps==0.7.5.9 
    31 "$EASY_INSTALL" -d "$WORKSPACE/utils" periodictable==1.3.0 
     31"$EASY_INSTALL" -d "$WORKSPACE/utils" periodictable==1.5.0 
    3232python deps.py 
    3333 
     
    4444# Build SasView ########################################################### 
    4545export PYTHONPATH=$PYTHONPATH:$WORKSPACE/$SASVIEW_INSTALL:$WORKSPACE/utils 
    46 python setup.py bdist_egg  
     46python setup.py bdist_egg 
    4747 
    4848 
  • build_tools/requirements.txt

    r131d94b r36ca21e  
    88lxml==2.3 
    99#PIL==1.1.7 
    10 periodictable==1.3.0 
     10periodictable==1.5.0 
    1111bumps==0.7.5.9 
    1212numpy>=1.7.1 
  • check_packages.py

    r3e1f417 r36ca21e  
    2727    'PIL': {'version': '1.1.7', 'import_name': 'Image', 'test': 'VERSION'}, 
    2828    'pylint': {'version': None, 'import_name': 'pylint', 'test': None}, 
    29     'periodictable': {'version': '1.3.0', 'import_name': 'periodictable', 'test': '__version__'}, 
     29    'periodictable': {'version': '1.5.0', 'import_name': 'periodictable', 'test': '__version__'}, 
    3030    'bumps': {'version': '0.7.5.9', 'import_name': 'bumps', 'test': '__version__'}, 
    3131    'numpy': {'version': '1.7.1', 'import_name': 'numpy', 'test': '__version__'}, 
  • run.py

    r2ecb0a5 r0225a3f  
     1#!/usr/bin/env python 
    12# -*- coding: utf-8 -*- 
    2 #!/usr/bin/env python 
    33""" 
    44Run sasview in place.  This allows sasview to use the python 
  • setup.py

    r7152c82 r36ca21e  
    6666    #             os.remove(file_path) 
    6767 
    68 if os.path.exists(SASVIEW_BUILD): 
     68 
     69# Optionally clean before build. 
     70dont_clean = 'update' in sys.argv 
     71if dont_clean: 
     72    sys.argv.remove('update') 
     73elif os.path.exists(SASVIEW_BUILD): 
    6974    print("Removing existing build directory", SASVIEW_BUILD, "for a clean build") 
    7075    shutil.rmtree(SASVIEW_BUILD) 
     
    387392 
    388393required = [ 
    389     'bumps>=0.7.5.9', 'periodictable>=1.3.1', 'pyparsing<2.0.0', 
     394    'bumps>=0.7.5.9', 'periodictable>=1.5.0', 'pyparsing<2.0.0', 
    390395 
    391396    # 'lxml>=2.2.2', 
  • src/sas/sascalc/calculator/BaseComponent.py

    r9a5097c r574adc7  
    143143                qdist[1].__class__.__name__ != 'ndarray': 
    144144                msg = "evalDistribution expects a list of 2 ndarrays" 
    145                 raise RuntimeError, msg 
     145                raise RuntimeError(msg) 
    146146 
    147147            # Extract qx and qy for code clarity 
     
    167167            mesg = "evalDistribution is expecting an ndarray of scalar q-values" 
    168168            mesg += " or a list [qx,qy] where qx,qy are 2D ndarrays." 
    169             raise RuntimeError, mesg 
     169            raise RuntimeError(mesg) 
    170170 
    171171 
     
    228228                    return 
    229229 
    230         raise ValueError, "Model does not contain parameter %s" % name 
     230        raise ValueError("Model does not contain parameter %s" % name) 
    231231 
    232232    def getParam(self, name): 
     
    250250                    return self.params[item] 
    251251 
    252         raise ValueError, "Model does not contain parameter %s" % name 
     252        raise ValueError("Model does not contain parameter %s" % name) 
    253253 
    254254    def getParamList(self): 
     
    294294        add 
    295295        """ 
    296         raise ValueError, "Model operation are no longer supported" 
     296        raise ValueError("Model operation are no longer supported") 
    297297    def __sub__(self, other): 
    298298        """ 
    299299        sub 
    300300        """ 
    301         raise ValueError, "Model operation are no longer supported" 
     301        raise ValueError("Model operation are no longer supported") 
    302302    def __mul__(self, other): 
    303303        """ 
    304304        mul 
    305305        """ 
    306         raise ValueError, "Model operation are no longer supported" 
     306        raise ValueError("Model operation are no longer supported") 
    307307    def __div__(self, other): 
    308308        """ 
    309309        div 
    310310        """ 
    311         raise ValueError, "Model operation are no longer supported" 
     311        raise ValueError("Model operation are no longer supported") 
    312312 
    313313 
  • src/sas/sascalc/calculator/c_extensions/sld2i_module.cpp

    rb523c0e r1d014cb  
    55#include <stdio.h> 
    66#include <sld2i.hh> 
     7 
     8#if PY_MAJOR_VERSION < 3 
     9typedef void (*PyCapsule_Destructor)(PyObject *); 
     10typedef void (*PyCObject_Destructor)(void *); 
     11#define PyCapsule_New(pointer, name, destructor) (PyCObject_FromVoidPtr(pointer, (PyCObject_Destructor)destructor)) 
     12#define PyCapsule_GetPointer(capsule, name) (PyCObject_AsVoidPtr(capsule)) 
     13#endif 
     14 
    715 
    816// Utilities 
     
    2533 * Delete a GenI object 
    2634 */ 
    27 void del_sld2i(void *ptr){ 
    28         GenI* sld2i = static_cast<GenI *>(ptr); 
     35void 
     36del_sld2i(PyObject *obj){ 
     37        GenI* sld2i = static_cast<GenI *>(PyCapsule_GetPointer(obj, "GenI")); 
    2938        delete sld2i; 
    3039        return; 
     
    7180        OUTVECTOR(vol_pix_obj, vol_pix, n_x); 
    7281        GenI* sld2i = new GenI(n_pix,x_val,y_val,z_val,sldn_val,mx_val,my_val,mz_val,vol_pix,inspin,outspin,stheta); 
    73         return PyCObject_FromVoidPtr(sld2i, del_sld2i); 
     82        return PyCapsule_New(sld2i, "GenI", del_sld2i); 
    7483} 
    7584 
     
    97106 
    98107        // Set the array pointers 
    99         void *temp = PyCObject_AsVoidPtr(gen_obj); 
     108        void *temp = PyCapsule_GetPointer(gen_obj, "GenI"); 
    100109        GenI* s = static_cast<GenI *>(temp); 
    101110 
     
    125134 
    126135        // Set the array pointers 
    127         void *temp = PyCObject_AsVoidPtr(gen_obj); 
     136        void *temp = PyCapsule_GetPointer(gen_obj, "GenI"); 
    128137        GenI* s = static_cast<GenI *>(temp); 
    129138 
     
    146155}; 
    147156 
    148  
    149 #ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */ 
    150 #define PyMODINIT_FUNC void 
     157#define MODULE_DOC "Sld2i C Library" 
     158#define MODULE_NAME "sld2i" 
     159#define MODULE_INIT2 initsld2i 
     160#define MODULE_INIT3 PyInit_sld2i 
     161#define MODULE_METHODS module_methods 
     162 
     163/* ==== boilerplate python 2/3 interface bootstrap ==== */ 
     164 
     165 
     166#if defined(WIN32) && !defined(__MINGW32__) 
     167    #define DLL_EXPORT __declspec(dllexport) 
     168#else 
     169    #define DLL_EXPORT 
    151170#endif 
    152 PyMODINIT_FUNC 
    153 initsld2i(void) 
    154 { 
    155     Py_InitModule3("sld2i", module_methods, "Sld2i module"); 
    156 } 
     171 
     172#if PY_MAJOR_VERSION >= 3 
     173 
     174  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT3(void) 
     175  { 
     176    static struct PyModuleDef moduledef = { 
     177      PyModuleDef_HEAD_INIT, 
     178      MODULE_NAME,         /* m_name */ 
     179      MODULE_DOC,          /* m_doc */ 
     180      -1,                  /* m_size */ 
     181      MODULE_METHODS,      /* m_methods */ 
     182      NULL,                /* m_reload */ 
     183      NULL,                /* m_traverse */ 
     184      NULL,                /* m_clear */ 
     185      NULL,                /* m_free */ 
     186    }; 
     187    return PyModule_Create(&moduledef); 
     188  } 
     189 
     190#else /* !PY_MAJOR_VERSION >= 3 */ 
     191 
     192  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT2(void) 
     193  { 
     194    Py_InitModule4(MODULE_NAME, 
     195                 MODULE_METHODS, 
     196                 MODULE_DOC, 
     197                 0, 
     198                 PYTHON_API_VERSION 
     199                 ); 
     200  } 
     201 
     202#endif /* !PY_MAJOR_VERSION >= 3 */ 
  • src/sas/sascalc/calculator/instrument.py

    r9a5097c r574adc7  
    222222        """ 
    223223        # check if the wavelength is in range 
    224         if min(band) < self.min or\ 
    225                 max(band) > self.max: 
    226             raise 
     224        if min(band) < self.min or max(band) > self.max: 
     225            raise ValueError("band out of range") 
    227226        self.band = band 
    228227 
     
    239238        """ 
    240239        # check if the wavelength is in range 
    241         if wavelength < min(self.band) or\ 
    242                 wavelength > max(self.band): 
    243             raise 
     240        if wavelength < min(self.band) or wavelength > max(self.band): 
     241            raise ValueError("wavelength out of range") 
    244242        self.wavelength = wavelength 
    245243        validate(wavelength) 
     
    324322            plt.show() 
    325323        except: 
    326             raise RuntimeError, "Can't import matplotlib required to plot..." 
     324            raise RuntimeError("Can't import matplotlib required to plot...") 
    327325 
    328326 
  • src/sas/sascalc/calculator/resolution_calculator.py

    r7432acb r574adc7  
    44instrumental parameters. 
    55""" 
    6 from instrument import Sample 
    7 from instrument import Detector 
    8 from instrument import TOF as Neutron 
    9 from instrument import Aperture 
    10 # import math stuffs 
    11 from math import pi 
    12 from math import sqrt 
     6import sys 
     7from math import pi, sqrt 
    138import math 
     9import logging 
     10 
    1411import numpy as np 
    15 import sys 
    16 import logging 
     12 
     13from .instrument import Sample 
     14from .instrument import Detector 
     15from .instrument import TOF as Neutron 
     16from .instrument import Aperture 
    1717 
    1818logger = logging.getLogger(__name__) 
     
    208208        if wavelength == 0: 
    209209            msg = "Can't compute the resolution: the wavelength is zero..." 
    210             raise RuntimeError, msg 
     210            raise RuntimeError(msg) 
    211211        return self.intensity 
    212212 
     
    379379        if qx_min < self.qx_min: 
    380380            self.qx_min = qx_min 
    381             #raise ValueError, msg 
     381            #raise ValueError(msg) 
    382382        if qx_max > self.qx_max: 
    383383            self.qx_max = qx_max 
    384             #raise ValueError, msg 
     384            #raise ValueError(msg) 
    385385        if qy_min < self.qy_min: 
    386386            self.qy_min = qy_min 
    387             #raise ValueError, msg 
     387            #raise ValueError(msg) 
    388388        if qy_max > self.qy_max: 
    389389            self.qy_max = qy_max 
    390             #raise ValueError, msg 
     390            #raise ValueError(msg) 
    391391        if not full_cal: 
    392392            return None 
     
    503503        # otherwise 
    504504        else: 
    505             raise ValueError, " Improper input..." 
     505            raise ValueError(" Improper input...") 
    506506        # get them squared 
    507507        sigma = x_comp * x_comp 
     
    706706            #self.set_wavelength(wavelength) 
    707707        else: 
    708             raise 
     708            raise TypeError("invalid wavlength---should be list or float") 
    709709 
    710710    def set_wave_spread(self, wavelength_spread): 
     
    717717            self.wave.set_wave_spread_list([wavelength_spread]) 
    718718        else: 
    719             raise 
     719            raise TypeError("invalid wavelength spread---should be list or float") 
    720720 
    721721    def set_wavelength(self, wavelength): 
     
    766766        """ 
    767767        if len(size) < 1 or len(size) > 2: 
    768             raise RuntimeError, "The length of the size must be one or two." 
     768            raise RuntimeError("The length of the size must be one or two.") 
    769769        self.aperture.set_source_size(size) 
    770770 
     
    783783        """ 
    784784        if len(size) < 1 or len(size) > 2: 
    785             raise RuntimeError, "The length of the size must be one or two." 
     785            raise RuntimeError("The length of the size must be one or two.") 
    786786        self.aperture.set_sample_size(size) 
    787787 
     
    806806        """ 
    807807        if len(distance) < 1 or len(distance) > 2: 
    808             raise RuntimeError, "The length of the size must be one or two." 
     808            raise RuntimeError("The length of the size must be one or two.") 
    809809        self.aperture.set_sample_distance(distance) 
    810810 
     
    816816        """ 
    817817        if len(distance) < 1 or len(distance) > 2: 
    818             raise RuntimeError, "The length of the size must be one or two." 
     818            raise RuntimeError("The length of the size must be one or two.") 
    819819        self.sample.set_distance(distance) 
    820820 
     
    826826        """ 
    827827        if len(distance) < 1 or len(distance) > 2: 
    828             raise RuntimeError, "The length of the size must be one or two." 
     828            raise RuntimeError("The length of the size must be one or two.") 
    829829        self.detector.set_distance(distance) 
    830830 
     
    998998            pix_y_size = detector_pix_size[1] 
    999999        else: 
    1000             raise ValueError, " Input value format error..." 
     1000            raise ValueError(" Input value format error...") 
    10011001        # Sample to detector distance = sample slit to detector 
    10021002        # minus sample offset 
  • src/sas/sascalc/calculator/sas_gen.py

    rf2ea95a rb58265c3  
    55from __future__ import print_function 
    66 
    7 import sas.sascalc.calculator.core.sld2i as mod 
    8 from sas.sascalc.calculator.BaseComponent import BaseComponent 
     7import os 
     8import sys 
     9import copy 
     10import logging 
     11 
    912from periodictable import formula 
    1013from periodictable import nsf 
    1114import numpy as np 
    12 import os 
    13 import copy 
    14 import sys 
    15 import logging 
     15 
     16from .core import sld2i as mod 
     17from .BaseComponent import BaseComponent 
    1618 
    1719logger = logging.getLogger(__name__) 
     20 
     21if sys.version_info[0] < 3: 
     22    def decode(s): 
     23        return s 
     24else: 
     25    def decode(s): 
     26        return s.decode() if isinstance(s, bytes) else s 
    1827 
    1928MFACTOR_AM = 2.853E-12 
     
    3443        factor = MFACTOR_MT 
    3544    else: 
    36         raise ValueError, "Invalid valueunit" 
     45        raise ValueError("Invalid valueunit") 
    3746    sld_m = factor * mag 
    3847    return sld_m 
     
    100109        """ 
    101110        if self.data_vol is None: 
    102             raise 
     111            raise TypeError("data_vol is missing") 
    103112        self.data_vol = volume 
    104113 
     
    174183            if len(x[1]) > 0: 
    175184                msg = "Not a 1D." 
    176                 raise ValueError, msg 
     185                raise ValueError(msg) 
    177186            i_out = np.zeros_like(x[0]) 
    178187            # 1D I is found at y =0 in the 2D pattern 
     
    181190        else: 
    182191            msg = "Q must be given as list of qx's and qy's" 
    183             raise ValueError, msg 
     192            raise ValueError(msg) 
    184193 
    185194    def runXY(self, x=0.0): 
     
    196205        else: 
    197206            msg = "Q must be given as list of qx's and qy's" 
    198             raise ValueError, msg 
     207            raise ValueError(msg) 
    199208 
    200209    def evalDistribution(self, qdist): 
     
    214223            mesg = "evalDistribution is expecting an ndarray of " 
    215224            mesg += "a list [qx,qy] where qx,qy are arrays." 
    216             raise RuntimeError, mesg 
     225            raise RuntimeError(mesg) 
    217226 
    218227class OMF2SLD(object): 
     
    288297                z_dir2 *= z_dir2 
    289298                mask = (x_dir2 + y_dir2 + z_dir2) <= 1.0 
    290             except: 
     299            except Exception: 
    291300                logger.error(sys.exc_value) 
    292301        self.output = MagSLD(self.pos_x[mask], self.pos_y[mask], 
     
    313322        :Params length: data length 
    314323        """ 
    315         msg = "Error: Inconsistent data length." 
    316         if len(self.pos_x) != length: 
    317             raise ValueError, msg 
    318         if len(self.pos_y) != length: 
    319             raise ValueError, msg 
    320         if len(self.pos_z) != length: 
    321             raise ValueError, msg 
    322         if len(self.mx) != length: 
    323             raise ValueError, msg 
    324         if len(self.my) != length: 
    325             raise ValueError, msg 
    326         if len(self.mz) != length: 
    327             raise ValueError, msg 
     324        parts = (self.pos_x, self.pos_y, self.pos_z, self.mx, self.my, self.mz) 
     325        if any(len(v) != length for v in parts): 
     326            raise ValueError("Error: Inconsistent data length.") 
    328327 
    329328    def remove_null_points(self, remove=False, recenter=False): 
     
    378377        try: 
    379378            input_f = open(path, 'rb') 
    380             buff = input_f.read() 
     379            buff = decode(input_f.read()) 
    381380            lines = buff.split('\n') 
    382381            input_f.close() 
     
    384383            valueunit = None 
    385384            for line in lines: 
    386                 toks = line.split() 
     385                line = line.strip() 
    387386                # Read data 
    388                 try: 
    389                     _mx = float(toks[0]) 
    390                     _my = float(toks[1]) 
    391                     _mz = float(toks[2]) 
    392                     _mx = mag2sld(_mx, valueunit) 
    393                     _my = mag2sld(_my, valueunit) 
    394                     _mz = mag2sld(_mz, valueunit) 
    395                     mx = np.append(mx, _mx) 
    396                     my = np.append(my, _my) 
    397                     mz = np.append(mz, _mz) 
    398                 except: 
    399                     # Skip non-data lines 
    400                     logger.error(sys.exc_value) 
     387                if line and not line.startswith('#'): 
     388                    try: 
     389                        toks = line.split() 
     390                        _mx = float(toks[0]) 
     391                        _my = float(toks[1]) 
     392                        _mz = float(toks[2]) 
     393                        _mx = mag2sld(_mx, valueunit) 
     394                        _my = mag2sld(_my, valueunit) 
     395                        _mz = mag2sld(_mz, valueunit) 
     396                        mx = np.append(mx, _mx) 
     397                        my = np.append(my, _my) 
     398                        mz = np.append(mz, _mz) 
     399                    except Exception as exc: 
     400                        # Skip non-data lines 
     401                        logger.error(str(exc)+" when processing %r"%line) 
    401402                #Reading Header; Segment count ignored 
    402403                s_line = line.split(":", 1) 
     
    415416                        msg = "Error: \n" 
    416417                        msg += "We accept only m as meshunit" 
    417                         raise ValueError, msg 
     418                        raise ValueError(msg) 
    418419                if s_line[0].lower().count("xbase") > 0: 
    419420                    xbase = s_line[1].lstrip() 
     
    482483            output.set_m(mx, my, mz) 
    483484            return output 
    484         except: 
     485        except Exception: 
    485486            msg = "%s is not supported: \n" % path 
    486487            msg += "We accept only Text format OMF file." 
    487             raise RuntimeError, msg 
     488            raise RuntimeError(msg) 
    488489 
    489490class PDBReader(object): 
     
    522523        try: 
    523524            input_f = open(path, 'rb') 
    524             buff = input_f.read() 
     525            buff = decode(input_f.read()) 
    525526            lines = buff.split('\n') 
    526527            input_f.close() 
     
    536537                            float(line[12]) 
    537538                            atom_name = atom_name[1].upper() 
    538                         except: 
     539                        except Exception: 
    539540                            if len(atom_name) == 4: 
    540541                                atom_name = atom_name[0].upper() 
     
    559560                            vol = 1.0e+24 * atom.mass / atom.density / NA 
    560561                            vol_pix = np.append(vol_pix, vol) 
    561                         except: 
    562                             print("Error: set the sld of %s to zero"% atom_name) 
     562                        except Exception: 
     563                            logger.error("Error: set the sld of %s to zero"% atom_name) 
    563564                            sld_n = np.append(sld_n, 0.0) 
    564565                        sld_mx = np.append(sld_mx, 0) 
     
    573574                            try: 
    574575                                int_val = int(val) 
    575                             except: 
     576                            except Exception: 
    576577                                break 
    577578                            if int_val == 0: 
     
    592593                        y_lines.append(y_line) 
    593594                        z_lines.append(z_line) 
    594                 except: 
     595                except Exception: 
    595596                    logger.error(sys.exc_value) 
    596597 
     
    604605            output.sld_unit = '1/A^(2)' 
    605606            return output 
    606         except: 
    607             raise RuntimeError, "%s is not a sld file" % path 
     607        except Exception: 
     608            raise RuntimeError("%s is not a sld file" % path) 
    608609 
    609610    def write(self, path, data): 
     
    657658                elif ncols == 7: 
    658659                    vol_pix = None 
    659             except: 
     660            except Exception: 
    660661                # For older version of numpy 
    661662                input_f = open(path, 'rb') 
    662                 buff = input_f.read() 
     663                buff = decode(input_f.read()) 
    663664                lines = buff.split('\n') 
    664665                input_f.close() 
     
    683684                            _vol_pix = float(toks[7]) 
    684685                            vol_pix = np.append(vol_pix, _vol_pix) 
    685                         except: 
     686                        except Exception: 
    686687                            vol_pix = None 
    687                     except: 
     688                    except Exception: 
    688689                        # Skip non-data lines 
    689690                        logger.error(sys.exc_value) 
     
    696697                output.set_pixel_volumes(vol_pix) 
    697698            return output 
    698         except: 
    699             raise RuntimeError, "%s is not a sld file" % path 
     699        except Exception: 
     700            raise RuntimeError("%s is not a sld file" % path) 
    700701 
    701702    def write(self, path, data): 
     
    706707        """ 
    707708        if path is None: 
    708             raise ValueError, "Missing the file path." 
     709            raise ValueError("Missing the file path.") 
    709710        if data is None: 
    710             raise ValueError, "Missing the data to save." 
     711            raise ValueError("Missing the data to save.") 
    711712        x_val = data.pos_x 
    712713        y_val = data.pos_y 
     
    977978                self.ynodes = int(ydist) + 1 
    978979                self.znodes = int(zdist) + 1 
    979             except: 
     980            except Exception: 
    980981                self.xnodes = None 
    981982                self.ynodes = None 
     
    10121013                self.set_pixel_volumes(vol) 
    10131014                self.has_stepsize = True 
    1014             except: 
     1015            except Exception: 
    10151016                self.xstepsize = None 
    10161017                self.ystepsize = None 
     
    10571058    reader = SLDReader() 
    10581059    oreader = OMFReader() 
    1059     output = reader.read(tfpath) 
    1060     ooutput = oreader.read(ofpath) 
     1060    output = decode(reader.read(tfpath)) 
     1061    ooutput = decode(oreader.read(ofpath)) 
    10611062    foutput = OMF2SLD() 
    10621063    foutput.set_data(ooutput) 
     
    10991100            break 
    11001101    oreader = OMFReader() 
    1101     ooutput = oreader.read(ofpath) 
     1102    ooutput = decode(oreader.read(ofpath)) 
    11021103    foutput = OMF2SLD() 
    11031104    foutput.set_data(ooutput) 
  • src/sas/sascalc/data_util/calcthread.py

    ra1b8fee r574adc7  
    66from __future__ import print_function 
    77 
    8 import thread 
    98import traceback 
    109import sys 
    1110import logging 
     11try: 
     12    import _thread as thread 
     13except ImportError: # CRUFT: python 2 support 
     14    import thread 
    1215 
    1316if sys.platform.count("darwin") > 0: 
    1417    import time 
    1518    stime = time.time() 
    16      
     19 
    1720    def clock(): 
    1821        return time.time() - stime 
    19      
     22 
    2023    def sleep(t): 
    2124        return time.sleep(t) 
     
    3538    CalcThread.__init__, passing it the keyword arguments for 
    3639    yieldtime, worktime, update and complete. 
    37      
     40 
    3841    When defining the compute() method you need to include code which 
    3942    allows the GUI to run.  They are as follows: :: 
     
    211214            self._lock.release() 
    212215            self._time_for_update += 1e6  # No more updates 
    213              
     216 
    214217            self.updatefn(**kwargs) 
    215218            sleep(self.yieldtime) 
  • src/sas/sascalc/data_util/nxsunit.py

    r8e9536f r574adc7  
    1313in the NeXus definition files. 
    1414 
    15 Unlike other units packages, this package does not carry the units along with  
     15Unlike other units packages, this package does not carry the units along with 
    1616the value but merely provides a conversion function for transforming values. 
    1717 
     
    6868    Ack! Allows, e.g., Coulomb and coulomb even though Coulomb is not 
    6969    a unit because some NeXus files store it that way! 
    70      
     70 
    7171    Returns a dictionary of names and scales. 
    7272    """ 
     
    7878                        n=1e-9,p=1e-12,f=1e-15) 
    7979    map = {abbr:1} 
    80     map.update([(P+abbr,scale) for (P,scale) in short_prefix.iteritems()]) 
     80    map.update([(P+abbr,scale) for (P,scale) in short_prefix.items()]) 
    8181    for name in [unit,unit.capitalize()]: 
    8282        map.update({name:1,name+'s':1}) 
    83         map.update([(P+name,scale) for (P,scale) in prefix.iteritems()]) 
    84         map.update([(P+'*'+name,scale) for (P,scale) in prefix.iteritems()]) 
    85         map.update([(P+name+'s',scale) for (P,scale) in prefix.iteritems()]) 
     83        map.update([(P+name,scale) for (P,scale) in prefix.items()]) 
     84        map.update([(P+'*'+name,scale) for (P,scale) in prefix.items()]) 
     85        map.update([(P+name+'s',scale) for (P,scale) in prefix.items()]) 
    8686    return map 
    8787 
     
    9191    """ 
    9292    map = {} 
    93     map.update([(name,scale) for name,scale in kw.iteritems()]) 
    94     map.update([(name+'s',scale) for name,scale in kw.iteritems()]) 
     93    map.update([(name,scale) for name,scale in kw.items()]) 
     94    map.update([(name+'s',scale) for name,scale in kw.items()]) 
    9595    return map 
    9696 
     
    101101    * WARNING * this will incorrect transform 10^3 to 103. 
    102102    """ 
    103     s.update((k.replace('^',''),v)  
    104              for k,v in s.items() 
     103    s.update((k.replace('^',''),v) 
     104             for k, v in list(s.items()) 
    105105             if '^' in k) 
    106106 
     
    130130    temperature.update(_build_metric_units('Celcius', 'C')) 
    131131    temperature.update(_build_metric_units('celcius', 'C')) 
    132      
     132 
    133133    charge = _build_metric_units('coulomb','C') 
    134134    charge.update({'microAmp*hour':0.0036}) 
    135135 
    136136    sld = { '10^-6 Angstrom^-2': 1e-6, 'Angstrom^-2': 1 } 
    137     Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1,  
     137    Q = { 'invA': 1, 'invAng': 1, 'invAngstroms': 1, '1/A': 1, 
    138138          '10^-3 Angstrom^-1': 1e-3, '1/cm': 1e-8, '1/m': 1e-10, 
    139139          'nm^-1': 0.1, '1/nm': 0.1, 'n_m^-1': 0.1 } 
     
    189189 
    190190def _check(expect,get): 
    191     if expect != get: raise ValueError, "Expected %s but got %s"%(expect,get) 
     191    if expect != get: 
     192        raise ValueError("Expected %s but got %s"%(expect, get)) 
    192193     #print expect,"==",get 
    193194 
     
    202203    _check(123,Converter('a.u.')(123,units='s')) # arbitrary units always returns the same value 
    203204    _check(123,Converter('a.u.')(123,units='')) # arbitrary units always returns the same value 
    204     try: Converter('help') 
    205     except KeyError: pass 
    206     else: raise Exception("unknown unit did not raise an error") 
     205    try: 
     206        Converter('help') 
     207    except KeyError: 
     208        pass 
     209    else: 
     210        raise Exception("unknown unit did not raise an error") 
    207211 
    208212    # TODO: more tests 
  • src/sas/sascalc/data_util/odict.py

    rb699768 r574adc7  
    3939    """ 
    4040    A class of dictionary that keeps the insertion order of keys. 
    41      
     41 
    4242    All appropriate methods return keys, items, or values in an ordered way. 
    43      
     43 
    4444    All normal dictionary methods are available. Update and comparison is 
    4545    restricted to other OrderedDict objects. 
    46      
     46 
    4747    Various sequence methods are available, including the ability to explicitly 
    4848    mutate the key ordering. 
    49      
     49 
    5050    __contains__ tests: 
    51      
     51 
    5252    >>> d = OrderedDict(((1, 3),)) 
    5353    >>> 1 in d 
     
    5555    >>> 4 in d 
    5656    0 
    57      
     57 
    5858    __getitem__ tests: 
    59      
     59 
    6060    >>> OrderedDict(((1, 3), (3, 2), (2, 1)))[2] 
    6161    1 
     
    6363    Traceback (most recent call last): 
    6464    KeyError: 4 
    65      
     65 
    6666    __len__ tests: 
    67      
     67 
    6868    >>> len(OrderedDict()) 
    6969    0 
    7070    >>> len(OrderedDict(((1, 3), (3, 2), (2, 1)))) 
    7171    3 
    72      
     72 
    7373    get tests: 
    74      
     74 
    7575    >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    7676    >>> d.get(1) 
     
    8282    >>> d 
    8383    OrderedDict([(1, 3), (3, 2), (2, 1)]) 
    84      
     84 
    8585    has_key tests: 
    86      
     86 
    8787    >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    8888    >>> d.has_key(1) 
     
    9696        Create a new ordered dictionary. Cannot init from a normal dict, 
    9797        nor from kwargs, since items order is undefined in those cases. 
    98          
     98 
    9999        If the ``strict`` keyword argument is ``True`` (``False`` is the 
    100100        default) then when doing slice assignment - the ``OrderedDict`` you are 
    101101        assigning from *must not* contain any keys in the remaining dict. 
    102          
     102 
    103103        >>> OrderedDict() 
    104104        OrderedDict([]) 
     
    283283        """ 
    284284        Used for __repr__ and __str__ 
    285          
     285 
    286286        >>> r1 = repr(OrderedDict((('a', 'b'), ('c', 'd'), ('e', 'f')))) 
    287287        >>> r1 
     
    321321        >>> d 
    322322        OrderedDict([(0, 1), (1, 2), (5, 6), (7, 8), (3, 4)]) 
    323          
     323 
    324324        >>> a = OrderedDict(((0, 1), (1, 2), (2, 3)), strict=True) 
    325325        >>> a[3] = 4 
     
    345345        >>> a 
    346346        OrderedDict([(3, 4), (2, 3), (1, 2), (0, 1)]) 
    347          
     347 
    348348        >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)]) 
    349349        >>> d[:1] = 3 
    350350        Traceback (most recent call last): 
    351351        TypeError: slice assignment requires an OrderedDict 
    352          
     352 
    353353        >>> d = OrderedDict([(0, 1), (1, 2), (2, 3), (3, 4)]) 
    354354        >>> d[:1] = OrderedDict([(9, 8)]) 
     
    444444        """ 
    445445        Implemented so that access to ``sequence`` raises a warning. 
    446          
     446 
    447447        >>> d = OrderedDict() 
    448448        >>> d.sequence 
     
    463463        """ 
    464464        To allow deepcopy to work with OrderedDict. 
    465          
     465 
    466466        >>> from copy import deepcopy 
    467467        >>> a = OrderedDict([(1, 1), (2, 2), (3, 3)]) 
     
    490490    def items(self): 
    491491        """ 
    492         ``items`` returns a list of tuples representing all the  
     492        ``items`` returns a list of tuples representing all the 
    493493        ``(key, value)`` pairs in the dictionary. 
    494          
     494 
    495495        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    496496        >>> d.items() 
     
    505505        """ 
    506506        Return a list of keys in the ``OrderedDict``. 
    507          
     507 
    508508        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    509509        >>> d.keys() 
     
    515515        """ 
    516516        Return a list of all the values in the OrderedDict. 
    517          
     517 
    518518        Optionally you can pass in a list of values, which will replace the 
    519519        current list. The value list must be the same len as the OrderedDict. 
    520          
     520 
    521521        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    522522        >>> d.values() 
     
    596596        """ 
    597597        No dict.pop in Python 2.2, gotta reimplement it 
    598          
     598 
    599599        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    600600        >>> d.pop(3) 
     
    612612        """ 
    613613        if len(args) > 1: 
    614             raise TypeError, ('pop expected at most 2 arguments, got %s' % 
     614            raise TypeError('pop expected at most 2 arguments, got %s' % 
    615615                (len(args) + 1)) 
    616616        if key in self: 
     
    628628        Delete and return an item specified by index, not a random one as in 
    629629        dict. The index is -1 by default (the last item). 
    630          
     630 
    631631        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    632632        >>> d.popitem() 
     
    674674        """ 
    675675        Update from another OrderedDict or sequence of (key, value) pairs 
    676          
     676 
    677677        >>> d = OrderedDict(((1, 0), (0, 1))) 
    678678        >>> d.update(OrderedDict(((1, 3), (3, 2), (2, 1)))) 
     
    706706        """ 
    707707        Rename the key for a given value, without modifying sequence order. 
    708          
     708 
    709709        For the case where new_key already exists this raise an exception, 
    710710        since if new_key exists, it is ambiguous as to what happens to the 
    711711        associated values, and the position of new_key in the sequence. 
    712          
     712 
    713713        >>> od = OrderedDict() 
    714714        >>> od['a'] = 1 
     
    732732            raise ValueError("New key already exists: %r" % new_key) 
    733733        # rename sequence entry 
    734         value = self[old_key]  
     734        value = self[old_key] 
    735735        old_idx = self._sequence.index(old_key) 
    736736        self._sequence[old_idx] = new_key 
     
    742742        """ 
    743743        This method allows you to set the items in the dict. 
    744          
     744 
    745745        It takes a list of tuples - of the same sort returned by the ``items`` 
    746746        method. 
    747          
     747 
    748748        >>> d = OrderedDict() 
    749749        >>> d.setitems(((3, 1), (2, 3), (1, 2))) 
     
    760760        replace the current set. This must contain the same set of keys, but 
    761761        need not be in the same order. 
    762          
     762 
    763763        If you pass in new keys that don't match, a ``KeyError`` will be 
    764764        raised. 
    765          
     765 
    766766        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    767767        >>> d.keys() 
     
    791791        You can pass in a list of values, which will replace the 
    792792        current list. The value list must be the same len as the OrderedDict. 
    793          
     793 
    794794        (Or a ``ValueError`` is raised.) 
    795          
     795 
    796796        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    797797        >>> d.setvalues((1, 2, 3)) 
     
    813813        """ 
    814814        Return the position of the specified key in the OrderedDict. 
    815          
     815 
    816816        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    817817        >>> d.index(3) 
     
    826826        """ 
    827827        Takes ``index``, ``key``, and ``value`` as arguments. 
    828          
     828 
    829829        Sets ``key`` to ``value``, so that ``key`` is at position ``index`` in 
    830830        the OrderedDict. 
    831          
     831 
    832832        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    833833        >>> d.insert(0, 4, 0) 
     
    850850        """ 
    851851        Reverse the order of the OrderedDict. 
    852          
     852 
    853853        >>> d = OrderedDict(((1, 3), (3, 2), (2, 1))) 
    854854        >>> d.reverse() 
     
    861861        """ 
    862862        Sort the key order in the OrderedDict. 
    863          
     863 
    864864        This method takes the same arguments as the ``list.sort`` method on 
    865865        your version of Python. 
    866          
     866 
    867867        >>> d = OrderedDict(((4, 1), (2, 2), (3, 3), (1, 4))) 
    868868        >>> d.sort() 
     
    876876    """ 
    877877    Custom object for accessing the keys of an OrderedDict. 
    878      
     878 
    879879    Can be called like the normal ``OrderedDict.keys`` method, but also 
    880880    supports indexing and sequence methods. 
     
    897897        You cannot assign to keys, but you can do slice assignment to re-order 
    898898        them. 
    899          
     899 
    900900        You can only do slice assignment if the new set of keys is a reordering 
    901901        of the original set. 
     
    967967    """ 
    968968    Custom object for accessing the items of an OrderedDict. 
    969      
     969 
    970970    Can be called like the normal ``OrderedDict.items`` method, but also 
    971971    supports indexing and sequence methods. 
     
    10771077    """ 
    10781078    Custom object for accessing the values of an OrderedDict. 
    1079      
     1079 
    10801080    Can be called like the normal ``OrderedDict.values`` method, but also 
    10811081    supports indexing and sequence methods. 
     
    10991099        """ 
    11001100        Set the value at position i to value. 
    1101          
     1101 
    11021102        You can only do slice assignment to values if you supply a sequence of 
    11031103        equal length to the slice you are replacing. 
     
    11681168    Experimental version of OrderedDict that has a custom object for ``keys``, 
    11691169    ``values``, and ``items``. 
    1170      
     1170 
    11711171    These are callable sequence objects that work as methods, or can be 
    11721172    manipulated directly as sequences. 
    1173      
     1173 
    11741174    Test for ``keys``, ``items`` and ``values``. 
    1175      
     1175 
    11761176    >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4))) 
    11771177    >>> d 
     
    12931293    >>> d 
    12941294    SequenceOrderedDict([(1, 1), (2, 2), (3, 3)]) 
    1295      
     1295 
    12961296    >>> d = SequenceOrderedDict(((1, 2), (2, 3), (3, 4))) 
    12971297    >>> d 
  • src/sas/sascalc/data_util/registry.py

    r5a8cdbb rdc8d1c2  
    101101        extlist = [ext for ext in self.extensions() if path.endswith(ext)] 
    102102        # Sort matching extensions by decreasing order of length 
    103         extlist.sort(lambda a,b: len(a)<len(b)) 
     103        extlist.sort(key=len) 
    104104        # Combine loaders for matching extensions into one big list 
    105105        loaders = [] 
  • src/sas/sascalc/data_util/uncertainty.py

    r9a5097c r574adc7  
    22Uncertainty propagation class for arithmetic, log and exp. 
    33 
    4 Based on scalars or numpy vectors, this class allows you to store and  
     4Based on scalars or numpy vectors, this class allows you to store and 
    55manipulate values+uncertainties, with propagation of gaussian error for 
    66addition, subtraction, multiplication, division, power, exp and log. 
    77 
    88Storage properties are determined by the numbers used to set the value 
    9 and uncertainty.  Be sure to use floating point uncertainty vectors  
     9and uncertainty.  Be sure to use floating point uncertainty vectors 
    1010for inplace operations since numpy does not do automatic type conversion. 
    1111Normal operations can use mixed integer and floating point.  In place 
     
    1818 
    1919import numpy as np 
    20 import err1d 
    21 from formatnum import format_uncertainty 
     20 
     21from .import err1d 
     22from .formatnum import format_uncertainty 
    2223 
    2324__all__ = ['Uncertainty'] 
     
    2829    # Make standard deviation available 
    2930    def _getdx(self): return np.sqrt(self.variance) 
    30     def _setdx(self,dx):  
     31    def _setdx(self,dx): 
    3132        # Direct operation 
    3233        #    variance = dx**2 
     
    3839    # Constructor 
    3940    def __init__(self, x, variance=None): 
    40         self.x, self.variance = x, variance     
    41   
     41        self.x, self.variance = x, variance 
     42 
    4243    # Numpy array slicing operations 
    43     def __len__(self):  
     44    def __len__(self): 
    4445        return len(self.x) 
    45     def __getitem__(self,key):  
     46    def __getitem__(self,key): 
    4647        return Uncertainty(self.x[key],self.variance[key]) 
    4748    def __setitem__(self,key,value): 
     
    137138    def __idiv__(self, other): return self.__itruediv__(other) 
    138139 
    139          
     140 
    140141    # Unary ops 
    141142    def __neg__(self): 
     
    151152            return format_uncertainty(self.x,np.sqrt(self.variance)) 
    152153        else: 
    153             return [format_uncertainty(v,dv)  
     154            return [format_uncertainty(v,dv) 
    154155                    for v,dv in zip(self.x,np.sqrt(self.variance))] 
    155156    def __repr__(self): 
     
    219220    z = a/4 
    220221    assert z.x == 5./4 and z.variance == 3./4**2 
    221      
     222 
    222223    # Reverse scalar operations 
    223224    z = 4+a 
     
    229230    z = 4/a 
    230231    assert z.x == 4./5 and abs(z.variance - 3./5**4 * 4**2) < 1e-15 
    231      
     232 
    232233    # Power operations 
    233234    z = a**2 
     
    250251    assert z.x == 5./4 and abs(z.variance - (3./5**2 + 2./4**2)*(5./4)**2) < 1e-15 
    251252 
    252     # ===== Inplace operations =====     
     253    # ===== Inplace operations ===== 
    253254    # Scalar operations 
    254255    y = a+0; y += 4 
     
    308309    assert (z.x == 5./4).all() 
    309310    assert (abs(z.variance - (3./5**2 + 2./4**2)*(5./4)**2) < 1e-15).all() 
    310      
     311 
    311312    # printing; note that sqrt(3) ~ 1.7 
    312313    assert str(Uncertainty(5,3)) == "5.0(17)" 
  • src/sas/sascalc/dataloader/__init__.py

    rb699768 r574adc7  
    1 from data_info import * 
    2 from manipulations import * 
    3 from readers import * 
     1from .data_info import * 
     2from .manipulations import * 
     3from .readers import * 
  • src/sas/sascalc/dataloader/data_info.py

    rdeaa0c6 r9e6aeaf  
    716716                self.y_unit = '1/cm' 
    717717        except: # the data is not recognized/supported, and the user is notified 
    718             raise(TypeError, 'data not recognized, check documentation for supported 1D data formats') 
     718            raise TypeError('data not recognized, check documentation for supported 1D data formats') 
    719719 
    720720    def __str__(self): 
     
    796796                len(self.y) != len(other.y): 
    797797                msg = "Unable to perform operation: data length are not equal" 
    798                 raise ValueError, msg 
     798                raise ValueError(msg) 
    799799            # Here we could also extrapolate between data points 
    800800            TOLERANCE = 0.01 
     
    802802                if math.fabs((self.x[i] - other.x[i])/self.x[i]) > TOLERANCE: 
    803803                    msg = "Incompatible data sets: x-values do not match" 
    804                     raise ValueError, msg 
     804                    raise ValueError(msg) 
    805805 
    806806            # Check that the other data set has errors, otherwise 
     
    876876        if not isinstance(other, Data1D): 
    877877            msg = "Unable to perform operation: different types of data set" 
    878             raise ValueError, msg 
     878            raise ValueError(msg) 
    879879        return True 
    880880 
     
    948948 
    949949        if len(self.detector) > 0: 
    950             raise RuntimeError, "Data2D: Detector bank already filled at init" 
     950            raise RuntimeError("Data2D: Detector bank already filled at init") 
    951951 
    952952    def __str__(self): 
     
    10201020                len(self.qy_data) != len(other.qy_data): 
    10211021                msg = "Unable to perform operation: data length are not equal" 
    1022                 raise ValueError, msg 
     1022                raise ValueError(msg) 
    10231023            for ind in range(len(self.data)): 
    10241024                if math.fabs((self.qx_data[ind] - other.qx_data[ind])/self.qx_data[ind]) > TOLERANCE: 
    10251025                    msg = "Incompatible data sets: qx-values do not match: %s %s" % (self.qx_data[ind], other.qx_data[ind]) 
    1026                     raise ValueError, msg 
     1026                    raise ValueError(msg) 
    10271027                if math.fabs((self.qy_data[ind] - other.qy_data[ind])/self.qy_data[ind]) > TOLERANCE: 
    10281028                    msg = "Incompatible data sets: qy-values do not match: %s %s" % (self.qy_data[ind], other.qy_data[ind]) 
    1029                     raise ValueError, msg 
     1029                    raise ValueError(msg) 
    10301030 
    10311031            # Check that the scales match 
     
    11081108        if not isinstance(other, Data2D): 
    11091109            msg = "Unable to perform operation: different types of data set" 
    1110             raise ValueError, msg 
     1110            raise ValueError(msg) 
    11111111        return True 
    11121112 
  • src/sas/sascalc/dataloader/file_reader_base_class.py

    rdeaa0c6 r9e6aeaf  
    66 
    77import os 
     8import sys 
    89import re 
    910import logging 
     11from abc import abstractmethod 
     12 
    1013import numpy as np 
    11 from abc import abstractmethod 
    12 from loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
     14from .loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
    1315    DataReaderException, DefaultReaderException 
    14 from data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\ 
     16from .data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D,\ 
    1517    combine_data_info_with_plottable 
    1618 
    1719logger = logging.getLogger(__name__) 
    1820 
     21if sys.version_info[0] < 3: 
     22    def decode(s): 
     23        return s 
     24else: 
     25    def decode(s): 
     26        return s.decode() if isinstance(s, bytes) else s 
    1927 
    2028class FileReader(object): 
     
    7886        # Return a list of parsed entries that data_loader can manage 
    7987        return self.output 
     88 
     89    def nextline(self): 
     90        """ 
     91        Returns the next line in the file as a string. 
     92        """ 
     93        #return self.f_open.readline() 
     94        return decode(self.f_open.readline()) 
     95 
     96    def nextlines(self): 
     97        """ 
     98        Returns the next line in the file as a string. 
     99        """ 
     100        for line in self.f_open: 
     101            #yield line 
     102            yield decode(line) 
     103 
     104    def readall(self): 
     105        """ 
     106        Returns the entire file as a string. 
     107        """ 
     108        #return self.f_open.read() 
     109        return decode(self.f_open.read()) 
    80110 
    81111    def handle_error_message(self, msg): 
  • src/sas/sascalc/dataloader/loader.py

    rdcb91cf rdc8d1c2  
    2626import time 
    2727from zipfile import ZipFile 
     28 
    2829from sas.sascalc.data_util.registry import ExtensionRegistry 
     30 
    2931# Default readers are defined in the readers sub-module 
    30 import readers 
    31 from loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
     32from . import readers 
     33from .loader_exceptions import NoKnownLoaderException, FileContentsException,\ 
    3234    DefaultReaderException 
    33 from readers import ascii_reader 
    34 from readers import cansas_reader 
    35 from readers import cansas_reader_HDF5 
     35from .readers import ascii_reader 
     36from .readers import cansas_reader 
     37from .readers import cansas_reader_HDF5 
    3638 
    3739logger = logging.getLogger(__name__) 
     
    7375        try: 
    7476            return super(Registry, self).load(path, format=format) 
     77        #except Exception: raise  # for debugging, don't use fallback loader 
    7578        except NoKnownLoaderException as nkl_e: 
    7679            pass  # Try the ASCII reader 
     
    327330        extlist = [ext for ext in self.extensions() if path.endswith(ext)] 
    328331        # Sort matching extensions by decreasing order of length 
    329         extlist.sort(lambda a, b: len(a) < len(b)) 
     332        extlist.sort(key=len) 
    330333        # Combine loaders for matching extensions into one big list 
    331334        writers = [] 
     
    341344        # Raise an error if there are no matching extensions 
    342345        if len(writers) == 0: 
    343             raise ValueError, "Unknown file type for " + path 
     346            raise ValueError("Unknown file type for " + path) 
    344347        # All done 
    345348        return writers 
     
    360363            try: 
    361364                return fn(path, data) 
    362             except: 
     365            except Exception: 
    363366                pass  # give other loaders a chance to succeed 
    364367        # If we get here it is because all loaders failed 
  • src/sas/sascalc/dataloader/manipulations.py

    r324e0bf r574adc7  
    2626 
    2727#from data_info import plottable_2D 
    28 from data_info import Data1D 
     28from .data_info import Data1D 
    2929 
    3030 
  • src/sas/sascalc/dataloader/readers/__init__.py

    r488f3a5 raaa801e  
    11# Method to associate extensions to default readers 
    2 from associations import read_associations 
     2from .associations import read_associations 
  • src/sas/sascalc/dataloader/readers/abs_reader.py

    rffb6474 r1efbc190  
    1111 
    1212import logging 
     13 
    1314import numpy as np 
    14 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    15 from sas.sascalc.dataloader.data_info import DataInfo, plottable_1D, Data1D,\ 
    16     Detector 
    17 from sas.sascalc.dataloader.loader_exceptions import FileContentsException,\ 
    18     DefaultReaderException 
     15 
     16from sas.sascalc.data_util.nxsunit import Converter 
     17from ..file_reader_base_class import FileReader 
     18from ..data_info import DataInfo, plottable_1D, Data1D, Detector 
     19from ..loader_exceptions import FileContentsException, DefaultReaderException 
    1920 
    2021logger = logging.getLogger(__name__) 
     
    3132    # List of allowed extensions 
    3233    ext = ['.abs'] 
    33      
     34 
    3435    def get_file_contents(self): 
    35         """  
     36        """ 
    3637        Get the contents of the file 
    37          
     38 
    3839        :raise RuntimeError: when the file can't be opened 
    3940        :raise ValueError: when the length of the data vectors are inconsistent 
    4041        """ 
    41         buff = self.f_open.read() 
     42        buff = self.readall() 
    4243        filepath = self.f_open.name 
    4344        lines = buff.splitlines() 
    44         self.has_converter = True 
    45         try: 
    46             from sas.sascalc.data_util.nxsunit import Converter 
    47         except: 
    48             self.has_converter = False 
    4945        self.output = [] 
    5046        self.current_datainfo = DataInfo() 
     
    7571                try: 
    7672                    value = float(line_toks[1]) 
    77                     if self.has_converter and \ 
    78                             self.current_datainfo.source.wavelength_unit != 'A': 
     73                    if self.current_datainfo.source.wavelength_unit != 'A': 
    7974                        conv = Converter('A') 
    8075                        self.current_datainfo.source.wavelength = conv(value, 
     
    8984                try: 
    9085                    value = float(line_toks[3]) 
    91                     if self.has_converter and detector.distance_unit != 'm': 
     86                    if detector.distance_unit != 'm': 
    9287                        conv = Converter('m') 
    9388                        detector.distance = conv(value, 
     
    9590                    else: 
    9691                        detector.distance = value 
    97                 except: 
     92                except Exception: 
    9893                    msg = "ABSReader cannot read SDD from %s" % filepath 
    9994                    self.current_datainfo.errors.append(msg) 
     
    109104                # Sample thickness in mm 
    110105                try: 
    111                     value = float(line_toks[5][:-1]) 
    112                     if self.has_converter and \ 
    113                             self.current_datainfo.sample.thickness_unit != 'cm': 
     106                    # ABS writer adds 'C' with no space to the end of the 
     107                    # thickness column.  Remove it if it is there before 
     108                    # converting the thickness. 
     109                    if line_toks[5][-1] not in '012345679.': 
     110                        value = float(line_toks[5][:-1]) 
     111                    else: 
     112                        value = float(line_toks[5]) 
     113                    if self.current_datainfo.sample.thickness_unit != 'cm': 
    114114                        conv = Converter('cm') 
    115115                        self.current_datainfo.sample.thickness = conv(value, 
     
    134134 
    135135                # Bin size 
    136                 if self.has_converter and detector.pixel_size_unit != 'mm': 
     136                if detector.pixel_size_unit != 'mm': 
    137137                    conv = Converter('mm') 
    138138                    detector.pixel_size.x = conv(5.08, 
     
    146146                # Store beam center in distance units 
    147147                # Det 640 x 640 mm 
    148                 if self.has_converter and detector.beam_center_unit != 'mm': 
     148                if detector.beam_center_unit != 'mm': 
    149149                    conv = Converter('mm') 
    150150                    detector.beam_center.x = conv(center_x * 5.08, 
    151151                                     units=detector.beam_center_unit) 
    152152                    detector.beam_center.y = conv(center_y * 5.08, 
    153                                     units=detector.beam_center_unit) 
     153                                     units=detector.beam_center_unit) 
    154154                else: 
    155155                    detector.beam_center.x = center_x * 5.08 
  • src/sas/sascalc/dataloader/readers/anton_paar_saxs_reader.py

    rfafe52a ra5bd87a  
    6363        ## Reinitialize the class when loading a new data file to reset all class variables 
    6464        self.reset_state() 
    65         buff = self.f_open.read() 
     65        buff = self.readall() 
    6666        self.raw_data = buff.splitlines() 
    6767        self.read_data() 
  • src/sas/sascalc/dataloader/readers/ascii_reader.py

    r7b07fbe r9e6aeaf  
    4545        """ 
    4646 
    47         buff = self.f_open.read() 
     47        buff = self.readall() 
    4848        filepath = self.f_open.name 
    4949        lines = buff.splitlines() 
     
    130130                # Reset # of lines of data candidates 
    131131                candidate_lines = 0 
    132          
     132 
    133133        if not is_data: 
    134134            self.set_all_to_none() 
  • src/sas/sascalc/dataloader/readers/associations.py

    rce8c7bd r574adc7  
    4040    """ 
    4141    # For each FileType entry, get the associated reader and extension 
    42     for ext, reader in settings.iteritems(): 
     42    for ext, reader in settings.items(): 
    4343        if reader is not None and ext is not None: 
    4444            # Associate the extension with a particular reader 
     
    4747            # and remove the extra line below. 
    4848            try: 
    49                 exec "import %s" % reader 
    50                 exec "loader.associate_file_type('%s', %s)" % (ext.lower(), 
    51                                                                 reader) 
    52                 exec "loader.associate_file_type('%s', %s)" % (ext.upper(), 
    53                                                                 reader) 
     49                exec("from . import %s" % reader) 
     50                exec("loader.associate_file_type('%s', %s)" 
     51                     % (ext.lower(), reader)) 
     52                exec("loader.associate_file_type('%s', %s)" 
     53                     % (ext.upper(), reader)) 
    5454            except: 
    5555                msg = "read_associations: skipping association" 
  • src/sas/sascalc/dataloader/readers/cansas_reader.py

    r62160509 r9e6aeaf  
    11import logging 
    2 import numpy as np 
    32import os 
    43import sys 
    54import datetime 
    65import inspect 
    7 # For saving individual sections of data 
    8 from sas.sascalc.dataloader.data_info import Data1D, Data2D, DataInfo, \ 
    9     plottable_1D, plottable_2D 
    10 from sas.sascalc.dataloader.data_info import Collimation, TransmissionSpectrum, \ 
    11     Detector, Process, Aperture 
    12 from sas.sascalc.dataloader.data_info import \ 
    13     combine_data_info_with_plottable as combine_data 
    14 import sas.sascalc.dataloader.readers.xml_reader as xml_reader 
    15 from sas.sascalc.dataloader.readers.xml_reader import XMLreader 
    16 from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants, CurrentLevel 
    17 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, \ 
    18     DefaultReaderException, DataReaderException 
     6 
     7import numpy as np 
    198 
    209# The following 2 imports *ARE* used. Do not remove either. 
     
    2312 
    2413from lxml import etree 
     14 
     15from sas.sascalc.data_util.nxsunit import Converter 
     16 
     17# For saving individual sections of data 
     18from ..data_info import Data1D, Data2D, DataInfo, plottable_1D, plottable_2D, \ 
     19    Collimation, TransmissionSpectrum, Detector, Process, Aperture, \ 
     20    combine_data_info_with_plottable as combine_data 
     21from ..loader_exceptions import FileContentsException, DefaultReaderException, \ 
     22    DataReaderException 
     23from . import xml_reader 
     24from .xml_reader import XMLreader 
     25from .cansas_constants import CansasConstants, CurrentLevel 
    2526 
    2627logger = logging.getLogger(__name__) 
     
    3334INVALID_XML = "\n\nThe loaded xml file, {0} does not fully meet the CanSAS v1.x specification. SasView loaded " + \ 
    3435              "as much of the data as possible.\n\n" 
    35 HAS_CONVERTER = True 
    36 try: 
    37     from sas.sascalc.data_util.nxsunit import Converter 
    38 except ImportError: 
    39     HAS_CONVERTER = False 
    4036 
    4137CONSTANTS = CansasConstants() 
     
    152148                raise fc_exc 
    153149        except Exception as e: # Convert all other exceptions to FileContentsExceptions 
    154             raise FileContentsException(e.message) 
     150            raise FileContentsException(str(e)) 
    155151        finally: 
    156152            if not self.f_open.closed: 
     
    622618                else: 
    623619                    save_in = "current_datainfo" 
    624                 exec "default_unit = self.{0}.{1}".format(save_in, unitname) 
    625                 if local_unit and default_unit and local_unit.lower() != default_unit.lower() \ 
    626                         and local_unit.lower() != "none": 
    627                     if HAS_CONVERTER == True: 
    628                         # Check local units - bad units raise KeyError 
    629                         data_conv_q = Converter(local_unit) 
    630                         value_unit = default_unit 
    631                         node_value = data_conv_q(node_value, units=default_unit) 
    632                     else: 
    633                         value_unit = local_unit 
    634                         err_msg = "Unit converter is not available.\n" 
     620                default_unit = getattrchain(self, '.'.join((save_in, unitname))) 
     621                if (local_unit and default_unit 
     622                        and local_unit.lower() != default_unit.lower() 
     623                        and local_unit.lower() != "none"): 
     624                    # Check local units - bad units raise KeyError 
     625                    #print("loading", tagname, node_value, local_unit, default_unit) 
     626                    data_conv_q = Converter(local_unit) 
     627                    value_unit = default_unit 
     628                    node_value = data_conv_q(node_value, units=default_unit) 
    635629                else: 
    636630                    value_unit = local_unit 
     
    644638                    err_msg += "expecting [{0}]".format(default_unit) 
    645639                value_unit = local_unit 
    646             except: 
     640            except Exception: 
    647641                err_msg = "CanSAS reader: unknown error converting " 
    648642                err_msg += "\"{0}\" unit [{1}]" 
     
    676670        doc, _ = self._to_xml_doc(datainfo) 
    677671        # Write the file 
    678         file_ref = open(filename, 'w') 
     672        file_ref = open(filename, 'wb') 
    679673        if self.encoding is None: 
    680674            self.encoding = "UTF-8" 
     
    867861        point = self.create_element("Idata") 
    868862        node.append(point) 
    869         qx = ','.join([str(datainfo.qx_data[i]) for i in xrange(len(datainfo.qx_data))]) 
    870         qy = ','.join([str(datainfo.qy_data[i]) for i in xrange(len(datainfo.qy_data))]) 
    871         intensity = ','.join([str(datainfo.data[i]) for i in xrange(len(datainfo.data))]) 
     863        qx = ','.join(str(v) for v in datainfo.qx_data) 
     864        qy = ','.join(str(v) for v in datainfo.qy_data) 
     865        intensity = ','.join(str(v) for v in datainfo.data) 
    872866 
    873867        self.write_node(point, "Qx", qx, 
     
    878872                        {'unit': datainfo._zunit}) 
    879873        if datainfo.err_data is not None: 
    880             err = ','.join([str(datainfo.err_data[i]) for i in 
    881                             xrange(len(datainfo.err_data))]) 
     874            err = ','.join(str(v) for v in datainfo.err_data) 
    882875            self.write_node(point, "Idev", err, 
    883876                            {'unit': datainfo._zunit}) 
    884877        if datainfo.dqy_data is not None: 
    885             dqy = ','.join([str(datainfo.dqy_data[i]) for i in 
    886                             xrange(len(datainfo.dqy_data))]) 
     878            dqy = ','.join(str(v) for v in datainfo.dqy_data) 
    887879            self.write_node(point, "Qydev", dqy, 
    888880                            {'unit': datainfo._yunit}) 
    889881        if datainfo.dqx_data is not None: 
    890             dqx = ','.join([str(datainfo.dqx_data[i]) for i in 
    891                             xrange(len(datainfo.dqx_data))]) 
     882            dqx = ','.join(str(v) for v in datainfo.dqx_data) 
    892883            self.write_node(point, "Qxdev", dqx, 
    893884                            {'unit': datainfo._xunit}) 
    894885        if datainfo.mask is not None: 
    895             mask = ','.join( 
    896                 ["1" if datainfo.mask[i] else "0" 
    897                  for i in xrange(len(datainfo.mask))]) 
     886            mask = ','.join("1" if v else "0" for v in datainfo.mask) 
    898887            self.write_node(point, "Mask", mask) 
    899888 
     
    12391228        try: 
    12401229            value = float(entry.text) 
    1241         except: 
     1230        except ValueError: 
    12421231            value = None 
    12431232 
     
    12481237            if units is not None: 
    12491238                toks = variable.split('.') 
    1250                 local_unit = None 
    1251                 exec "local_unit = storage.%s_unit" % toks[0] 
     1239                # TODO: why split() when accessing unit, but not when setting value? 
     1240                local_unit = getattr(storage, toks[0]+"_unit") 
    12521241                if local_unit is not None and units.lower() != local_unit.lower(): 
    1253                     if HAS_CONVERTER == True: 
    1254                         try: 
    1255                             conv = Converter(units) 
    1256                             exec "storage.%s = %g" % \ 
    1257                                 (variable, conv(value, units=local_unit)) 
    1258                         except: 
    1259                             _, exc_value, _ = sys.exc_info() 
    1260                             err_mess = "CanSAS reader: could not convert" 
    1261                             err_mess += " %s unit [%s]; expecting [%s]\n  %s" \ 
    1262                                 % (variable, units, local_unit, exc_value) 
    1263                             self.errors.add(err_mess) 
    1264                             if optional: 
    1265                                 logger.info(err_mess) 
    1266                             else: 
    1267                                 raise ValueError, err_mess 
    1268                     else: 
    1269                         err_mess = "CanSAS reader: unrecognized %s unit [%s];"\ 
    1270                         % (variable, units) 
    1271                         err_mess += " expecting [%s]" % local_unit 
     1242                    try: 
     1243                        conv = Converter(units) 
     1244                        setattrchain(storage, variable, conv(value, units=local_unit)) 
     1245                    except Exception: 
     1246                        _, exc_value, _ = sys.exc_info() 
     1247                        err_mess = "CanSAS reader: could not convert" 
     1248                        err_mess += " %s unit [%s]; expecting [%s]\n  %s" \ 
     1249                            % (variable, units, local_unit, exc_value) 
    12721250                        self.errors.add(err_mess) 
    12731251                        if optional: 
    12741252                            logger.info(err_mess) 
    12751253                        else: 
    1276                             raise ValueError, err_mess 
     1254                            raise ValueError(err_mess) 
    12771255                else: 
    1278                     exec "storage.%s = value" % variable 
     1256                    setattrchain(storage, variable, value) 
    12791257            else: 
    1280                 exec "storage.%s = value" % variable 
     1258                setattrchain(storage, variable, value) 
    12811259 
    12821260    # DO NOT REMOVE - used in saving and loading panel states. 
     
    12981276        entry = get_content(location, node) 
    12991277        if entry is not None and entry.text is not None: 
    1300             exec "storage.%s = entry.text.strip()" % variable 
     1278            setattrchain(storage, variable, entry.text.strip()) 
    13011279 
    13021280# DO NOT REMOVE Called by outside packages: 
     
    13411319        return True 
    13421320    return False 
     1321 
     1322def getattrchain(obj, chain, default=None): 
     1323    """Like getattr, but the attr may contain multiple parts separated by '.'""" 
     1324    for part in chain.split('.'): 
     1325        if hasattr(obj, part): 
     1326            obj = getattr(obj, part, None) 
     1327        else: 
     1328            return default 
     1329    return obj 
     1330 
     1331def setattrchain(obj, chain, value): 
     1332    """Like setattr, but the attr may contain multiple parts separated by '.'""" 
     1333    parts = list(chain.split('.')) 
     1334    for part in parts[-1]: 
     1335        obj = getattr(obj, part, None) 
     1336        if obj is None: 
     1337            raise ValueError("missing parent object "+part) 
     1338    setattr(obj, value) 
  • src/sas/sascalc/dataloader/readers/cansas_reader_HDF5.py

    rcd57c7d4 r7b50f14  
    99import sys 
    1010 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, plottable_2D,\ 
     11from ..data_info import plottable_1D, plottable_2D,\ 
    1212    Data1D, Data2D, DataInfo, Process, Aperture, Collimation, \ 
    1313    TransmissionSpectrum, Detector 
    14 from sas.sascalc.dataloader.data_info import combine_data_info_with_plottable 
    15 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DefaultReaderException 
    16 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    17  
     14from ..data_info import combine_data_info_with_plottable 
     15from ..loader_exceptions import FileContentsException, DefaultReaderException 
     16from ..file_reader_base_class import FileReader, decode 
     17 
     18def h5attr(node, key, default=None): 
     19    return decode(node.attrs.get(key, default)) 
    1820 
    1921class Reader(FileReader): 
     
    130132            # Get all information for the current key 
    131133            value = data.get(key) 
    132             if value.attrs.get(u'canSAS_class') is not None: 
    133                 class_name = value.attrs.get(u'canSAS_class') 
    134             else: 
    135                 class_name = value.attrs.get(u'NX_class') 
     134            class_name = h5attr(value, u'canSAS_class') 
     135            if class_name is None: 
     136                class_name = h5attr(value, u'NX_class') 
    136137            if class_name is not None: 
    137138                class_prog = re.compile(class_name) 
     
    225226 
    226227                for data_point in data_set: 
     228                    if data_point.dtype.char == 'S': 
     229                        data_point = decode(bytes(data_point)) 
    227230                    # Top Level Meta Data 
    228231                    if key == u'definition': 
     
    231234                        self.current_datainfo.run.append(data_point) 
    232235                        try: 
    233                             run_name = value.attrs['name'] 
     236                            run_name = h5attr(value, 'name') 
    234237                            run_dict = {data_point: run_name} 
    235238                            self.current_datainfo.run_name = run_dict 
    236                         except: 
     239                        except Exception: 
    237240                            pass 
    238241                    elif key == u'title': 
     
    576579        :return: unit for the value passed to the method 
    577580        """ 
    578         unit = value.attrs.get(u'units') 
     581        unit = h5attr(value, u'units') 
    579582        if unit is None: 
    580             unit = value.attrs.get(u'unit') 
     583            unit = h5attr(value, u'unit') 
    581584        # Convert the unit formats 
    582585        if unit == "1/A": 
  • src/sas/sascalc/dataloader/readers/danse_reader.py

    ra78a02f raf3e9f5  
    1414import math 
    1515import os 
     16import logging 
     17 
    1618import numpy as np 
    17 import logging 
    18 from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector 
    19 from sas.sascalc.dataloader.manipulations import reader2D_converter 
    20 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    21 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
     19 
     20from ..data_info import plottable_2D, DataInfo, Detector 
     21from ..manipulations import reader2D_converter 
     22from ..file_reader_base_class import FileReader 
     23from ..loader_exceptions import FileContentsException, DataReaderException 
    2224 
    2325logger = logging.getLogger(__name__) 
     
    7880        data_start_line = 1 
    7981        while read_on: 
    80             line = self.f_open.readline() 
     82            line = self.nextline() 
    8183            data_start_line += 1 
    8284            if line.find("DATA:") >= 0: 
     
    112114            raise FileContentsException(msg) 
    113115 
    114         for line_num, data_str in enumerate(self.f_open.readlines()): 
     116        for line_num, data_str in enumerate(self.nextlines()): 
    115117            toks = data_str.split() 
    116118            try: 
  • src/sas/sascalc/dataloader/readers/red2d_reader.py

    r2f85af7 rc8321cfc  
    1010###################################################################### 
    1111import os 
     12import math 
     13import time 
     14 
    1215import numpy as np 
    13 import math 
    14 from sas.sascalc.dataloader.data_info import plottable_2D, DataInfo, Detector 
    15 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    16 from sas.sascalc.dataloader.loader_exceptions import FileContentsException 
    17  
    18 # Look for unit converter 
    19 has_converter = True 
    20 try: 
    21     from sas.sascalc.data_util.nxsunit import Converter 
    22 except: 
    23     has_converter = False 
     16 
     17from sas.sascalc.data_util.nxsunit import Converter 
     18 
     19from ..data_info import plottable_2D, DataInfo, Detector 
     20from ..file_reader_base_class import FileReader 
     21from ..loader_exceptions import FileContentsException 
    2422 
    2523 
     
    3129    try: 
    3230        return float(x_point) 
    33     except: 
     31    except Exception: 
    3432        return 0 
    3533 
     
    5149        :param data: data2D 
    5250        """ 
    53         import time 
    5451        # Write the file 
    5552        try: 
     
    7269    def get_file_contents(self): 
    7370        # Read file 
    74         buf = self.f_open.read() 
     71        buf = self.readall() 
    7572        self.f_open.close() 
    7673        # Instantiate data object 
     
    119116                try: 
    120117                    wavelength = float(line_toks[1]) 
    121                     # Units 
    122                     if has_converter == True and \ 
    123                     self.current_datainfo.source.wavelength_unit != 'A': 
     118                    # Wavelength is stored in angstroms; convert if necessary 
     119                    if self.current_datainfo.source.wavelength_unit != 'A': 
    124120                        conv = Converter('A') 
    125121                        wavelength = conv(wavelength, 
    126122                                          units=self.current_datainfo.source.wavelength_unit) 
    127                 except: 
    128                     #Not required 
    129                     pass 
    130                 # Distance in mm 
     123                except Exception: 
     124                    pass  # Not required 
    131125                try: 
    132126                    distance = float(line_toks[3]) 
    133                     # Units 
    134                     if has_converter == True and self.current_datainfo.detector[0].distance_unit != 'm': 
     127                    # Distance is stored in meters; convert if necessary 
     128                    if self.current_datainfo.detector[0].distance_unit != 'm': 
    135129                        conv = Converter('m') 
    136130                        distance = conv(distance, 
    137131                            units=self.current_datainfo.detector[0].distance_unit) 
    138                 except: 
    139                     #Not required 
    140                     pass 
    141  
    142                 # Distance in meters 
     132                except Exception: 
     133                    pass  # Not required 
     134 
    143135                try: 
    144136                    transmission = float(line_toks[4]) 
    145                 except: 
    146                     #Not required 
    147                     pass 
     137                except Exception: 
     138                    pass  # Not required 
    148139 
    149140            if line.count("LAMBDA") > 0: 
     
    170161 
    171162            ## Read and get data. 
    172             if data_started == True: 
     163            if data_started: 
    173164                line_toks = line.split() 
    174165                if len(line_toks) == 0: 
     
    178169                col_num = len(line_toks) 
    179170                break 
     171 
    180172        # Make numpy array to remove header lines using index 
    181173        lines_array = np.array(lines) 
     
    203195        # Change it(string) into float 
    204196        #data_list = map(float,data_list) 
    205         data_list1 = map(check_point, data_list) 
     197        data_list1 = list(map(check_point, data_list)) 
    206198 
    207199        # numpy array form 
     
    211203        try: 
    212204            data_point = data_array.reshape(row_num, col_num).transpose() 
    213         except: 
     205        except Exception: 
    214206            msg = "red2d_reader can't read this file: Incorrect number of data points provided." 
    215207            raise FileContentsException(msg) 
     
    325317 
    326318        # Units of axes 
    327         self.current_dataset.xaxis("\\rm{Q_{x}}", 'A^{-1}') 
    328         self.current_dataset.yaxis("\\rm{Q_{y}}", 'A^{-1}') 
    329         self.current_dataset.zaxis("\\rm{Intensity}", "cm^{-1}") 
     319        self.current_dataset.xaxis(r"\rm{Q_{x}}", 'A^{-1}') 
     320        self.current_dataset.yaxis(r"\rm{Q_{y}}", 'A^{-1}') 
     321        self.current_dataset.zaxis(r"\rm{Intensity}", "cm^{-1}") 
    330322 
    331323        # Store loading process information 
  • src/sas/sascalc/dataloader/readers/sesans_reader.py

    rbe43448 r849094a  
    66    Jurrian Bakker 
    77""" 
     8import os 
     9 
    810import numpy as np 
    9 import os 
    10 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
    11 from sas.sascalc.dataloader.data_info import plottable_1D, DataInfo 
    12 from sas.sascalc.dataloader.loader_exceptions import FileContentsException, DataReaderException 
     11 
     12from ..file_reader_base_class import FileReader 
     13from ..data_info import plottable_1D, DataInfo 
     14from ..loader_exceptions import FileContentsException, DataReaderException 
    1315 
    1416# Check whether we have a converter available 
     
    4244        self.output = [] 
    4345 
    44         line = self.f_open.readline() 
     46        line = self.nextline() 
    4547        params = {} 
    4648        while not line.startswith("BEGIN_DATA"): 
     
    4850            if len(terms) >= 2: 
    4951                params[terms[0]] = " ".join(terms[1:]) 
    50             line = self.f_open.readline() 
     52            line = self.nextline() 
    5153        self.params = params 
    5254 
     
    6870                               "handled by other software.") 
    6971 
    70         headers = self.f_open.readline().split() 
     72        headers = self.nextline().split() 
    7173 
    7274        self._insist_header(headers, "SpinEchoLength") 
  • src/sas/sascalc/dataloader/readers/tiff_reader.py

    r959eb01 r574adc7  
    22#This software was developed by the University of Tennessee as part of the 
    33#Distributed Data Analysis of Neutron Scattering Experiments (DANSE) 
    4 #project funded by the US National Science Foundation.  
     4#project funded by the US National Science Foundation. 
    55#See the license text in license.txt 
    66#copyright 2008, University of Tennessee 
     
    3131    ## Extension 
    3232    ext = ['.tif', '.tiff'] 
    33          
     33 
    3434    def read(self, filename=None): 
    3535        """ 
    3636        Open and read the data in a file 
    37          
     37 
    3838        :param file: path of the file 
    3939        """ 
     
    4444        except: 
    4545            msg = "tiff_reader: could not load file. Missing Image module." 
    46             raise RuntimeError, msg 
    47          
     46            raise RuntimeError(msg) 
     47 
    4848        # Instantiate data object 
    4949        output = Data2D() 
    5050        output.filename = os.path.basename(filename) 
    51              
     51 
    5252        # Read in the image 
    5353        try: 
    5454            im = Image.open(filename) 
    5555        except: 
    56             raise  RuntimeError, "cannot open %s"%(filename) 
     56            raise  RuntimeError("cannot open %s"%(filename)) 
    5757        data = im.getdata() 
    5858 
     
    6161        output.err_data = np.zeros([im.size[0], im.size[1]]) 
    6262        output.mask = np.ones([im.size[0], im.size[1]], dtype=bool) 
    63          
     63 
    6464        # Initialize 
    6565        x_vals = [] 
     
    6969        for i_x in range(im.size[0]): 
    7070            x_vals.append(i_x) 
    71              
     71 
    7272        itot = 0 
    7373        for i_y in range(im.size[1]): 
     
    8080                logger.error("tiff_reader: had to skip a non-float point") 
    8181                continue 
    82              
     82 
    8383            # Get bin number 
    8484            if math.fmod(itot, im.size[0]) == 0: 
     
    8787            else: 
    8888                i_x += 1 
    89                  
     89 
    9090            output.data[im.size[1] - 1 - i_y][i_x] = value 
    91              
     91 
    9292            itot += 1 
    93                  
     93 
    9494        output.xbins = im.size[0] 
    9595        output.ybins = im.size[1] 
     
    102102        output.ymin = 0 
    103103        output.ymax = im.size[0] - 1 
    104          
     104 
    105105        # Store loading process information 
    106106        output.meta_data['loader'] = self.type_name 
  • src/sas/sascalc/dataloader/readers/xml_reader.py

    rcd57c7d4 r7b50f14  
    1616 
    1717import logging 
     18 
    1819from lxml import etree 
    1920from lxml.builder import E 
    20 from sas.sascalc.dataloader.file_reader_base_class import FileReader 
     21 
     22from ..file_reader_base_class import FileReader, decode 
    2123 
    2224logger = logging.getLogger(__name__) 
     
    151153        Converts an etree element into a string 
    152154        """ 
    153         return etree.tostring(elem, pretty_print=pretty_print, \ 
    154                               encoding=encoding) 
     155        return decode(etree.tostring(elem, pretty_print=pretty_print, 
     156                                     encoding=encoding)) 
    155157 
    156158    def break_processing_instructions(self, string, dic): 
  • src/sas/sascalc/file_converter/c_ext/bsl_loader.c

    r2ab9c432 rd5aeaa3  
    11#include <Python.h> 
    2 //#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION 
     2#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION 
    33#include <numpy/arrayobject.h> 
    44#include <stdio.h> 
     
    4444static void CLoader_dealloc(CLoader *self) { 
    4545    free(self->params.filename); 
    46     self->ob_type->tp_free((PyObject *)self); 
     46    Py_TYPE(self)->tp_free((PyObject *)self); 
    4747} 
    4848 
     
    237237 
    238238static PyTypeObject CLoaderType = { 
    239     PyObject_HEAD_INIT(NULL) 
    240     0,                         /*ob_size*/ 
     239    //PyObject_HEAD_INIT(NULL) 
     240    //0,                         /*ob_size*/ 
     241    PyVarObject_HEAD_INIT(NULL, 0) 
    241242    "CLoader",             /*tp_name*/ 
    242243    sizeof(CLoader),             /*tp_basicsize*/ 
     
    278279}; 
    279280 
    280 PyMODINIT_FUNC 
    281 initbsl_loader(void) 
     281/** 
     282 * Function used to add the model class to a module 
     283 * @param module: module to add the class to 
     284 */ 
     285void addCLoader(PyObject *module) 
    282286{ 
    283     PyObject *module; 
    284     module = Py_InitModule("bsl_loader", NULL); 
    285     import_array(); 
    286  
    287287    if (PyType_Ready(&CLoaderType) < 0) 
    288288        return; 
    289  
    290289    Py_INCREF(&CLoaderType); 
    291290    PyModule_AddObject(module, "CLoader", (PyObject *)&CLoaderType); 
    292291} 
     292 
     293#define MODULE_DOC "C module for loading bsl." 
     294#define MODULE_NAME "bsl_loader" 
     295#define MODULE_INIT2 initbsl_loader 
     296#define MODULE_INIT3 PyInit_bsl_loader 
     297#define MODULE_METHODS module_methods 
     298 
     299/* ==== boilerplate python 2/3 interface bootstrap ==== */ 
     300 
     301 
     302#if defined(WIN32) && !defined(__MINGW32__) 
     303    #define DLL_EXPORT __declspec(dllexport) 
     304#else 
     305    #define DLL_EXPORT 
     306#endif 
     307 
     308#if PY_MAJOR_VERSION >= 3 
     309 
     310  static PyMethodDef module_methods[] = { 
     311      {NULL} 
     312  }; 
     313 
     314  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT3(void) 
     315  { 
     316    static struct PyModuleDef moduledef = { 
     317      PyModuleDef_HEAD_INIT, 
     318      MODULE_NAME,         /* m_name */ 
     319      MODULE_DOC,          /* m_doc */ 
     320      -1,                  /* m_size */ 
     321      MODULE_METHODS,      /* m_methods */ 
     322      NULL,                /* m_reload */ 
     323      NULL,                /* m_traverse */ 
     324      NULL,                /* m_clear */ 
     325      NULL,                /* m_free */ 
     326    }; 
     327    PyObject* m = PyModule_Create(&moduledef); 
     328    import_array(); 
     329    addCLoader(m); 
     330    return m; 
     331  } 
     332 
     333#else /* !PY_MAJOR_VERSION >= 3 */ 
     334 
     335  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT2(void) 
     336  { 
     337    PyObject* m = Py_InitModule(MODULE_NAME, NULL); 
     338    import_array(); 
     339    addCLoader(m); 
     340  } 
     341 
     342#endif /* !PY_MAJOR_VERSION >= 3 */ 
  • src/sas/sascalc/file_converter/cansas_writer.py

    r7432acb r574adc7  
    3232        valid_class = all([issubclass(data.__class__, Data1D) for data in frame_data]) 
    3333        if not valid_class: 
    34             raise RuntimeError, ("The cansas writer expects an array of " 
     34            raise RuntimeError("The cansas writer expects an array of " 
    3535                "Data1D instances") 
    3636 
  • src/sas/sascalc/file_converter/nxcansas_writer.py

    r5e906207 r574adc7  
    166166            'wavelength_max': 'wavelength_max', 
    167167            'wavelength_spread': 'incident_wavelength_spread' } 
    168         for sasname, nxname in wavelength_keys.iteritems(): 
     168        for sasname, nxname in wavelength_keys.items(): 
    169169            value = getattr(data_info.source, sasname) 
    170170            units = getattr(data_info.source, sasname + '_unit') 
  • src/sas/sascalc/fit/AbstractFitEngine.py

    r50fcb09 r574adc7  
    251251            msg = "FitData1D: invalid error array " 
    252252            msg += "%d <> %d" % (np.shape(self.dy), np.size(fx)) 
    253             raise RuntimeError, msg 
     253            raise RuntimeError(msg) 
    254254        return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx] 
    255255 
  • src/sas/sascalc/fit/Loader.py

    ra1b8fee r574adc7  
    1818        self.dy = dy 
    1919        self.filename = None 
    20          
     20 
    2121    def set_filename(self, path=None): 
    2222        """ 
    23         Store path into a variable.If the user doesn't give  
     23        Store path into a variable.If the user doesn't give 
    2424        a path as a parameter a pop-up 
    2525        window appears to select the file. 
    26          
     26 
    2727        :param path: the path given by the user 
    28          
     28 
    2929        """ 
    3030        self.filename = path 
    31         
     31 
    3232    def get_filename(self): 
    3333        """ return the file's path""" 
    3434        return self.filename 
    35      
     35 
    3636    def set_values(self): 
    3737        """ Store the values loaded from file in local variables""" 
     
    4242            self.x = [] 
    4343            self.y = [] 
    44             self.dx = []  
     44            self.dx = [] 
    4545            self.dy = [] 
    4646            for line in lines: 
     
    5050                    y = float(toks[1]) 
    5151                    dy = float(toks[2]) 
    52                      
     52 
    5353                    self.x.append(x) 
    5454                    self.y.append(y) 
     
    5959            # Sanity check 
    6060            if not len(self.x) == len(self.dx): 
    61                 raise ValueError, "x and dx have different length" 
     61                raise ValueError("x and dx have different length") 
    6262            if not len(self.y) == len(self.dy): 
    63                 raise ValueError, "y and dy have different length" 
    64              
    65              
     63                raise ValueError("y and dy have different length") 
     64 
     65 
    6666    def get_values(self): 
    6767        """ Return x, y, dx, dy""" 
    6868        return self.x, self.y, self.dx, self.dy 
    69      
     69 
    7070    def load_data(self, data): 
    7171        """ Return plottable""" 
     
    7777        #Load its View class 
    7878        #plottable.reset_view() 
    79         
    80      
    81 if __name__ == "__main__":  
     79 
     80 
     81if __name__ == "__main__": 
    8282    load = Load() 
    8383    load.set_filename("testdata_line.txt") 
    84     print(load.get_filename())  
     84    print(load.get_filename()) 
    8585    load.set_values() 
    8686    print(load.get_values()) 
    87      
    88              
     87 
  • src/sas/sascalc/fit/MultiplicationModel.py

    r7432acb r574adc7  
    109109        """ 
    110110        ##set dispersion only from p_model 
    111         for name , value in self.p_model.dispersion.iteritems(): 
     111        for name , value in self.p_model.dispersion.items(): 
    112112            self.dispersion[name] = value 
    113113 
     
    135135        """ 
    136136 
    137         for name , value in self.p_model.params.iteritems(): 
     137        for name , value in self.p_model.params.items(): 
    138138            if not name in self.params.keys() and name not in self.excluded_params: 
    139139                self.params[name] = value 
    140140 
    141         for name , value in self.s_model.params.iteritems(): 
     141        for name , value in self.s_model.params.items(): 
    142142            #Remove the radius_effective from the (P*S) model parameters. 
    143143            if not name in self.params.keys() and name not in self.excluded_params: 
     
    155155        this model's details 
    156156        """ 
    157         for name, detail in self.p_model.details.iteritems(): 
     157        for name, detail in self.p_model.details.items(): 
    158158            if name not in self.excluded_params: 
    159159                self.details[name] = detail 
    160160 
    161         for name , detail in self.s_model.details.iteritems(): 
     161        for name , detail in self.s_model.details.items(): 
    162162            if not name in self.details.keys() or name not in self.exluded_params: 
    163163                self.details[name] = detail 
     
    245245                    return 
    246246 
    247         raise ValueError, "Model does not contain parameter %s" % name 
     247        raise ValueError("Model does not contain parameter %s" % name) 
    248248 
    249249 
  • src/sas/sascalc/fit/expression.py

    ra1b8fee r574adc7  
    5959    occur multiple times.  The return value is a set with the elements in 
    6060    no particular order. 
    61      
     61 
    6262    This is the first step in computing a dependency graph. 
    6363    """ 
     
    8181        offset = end 
    8282    pieces.append(expr[offset:]) 
    83      
     83 
    8484    # Join the pieces and return them 
    8585    return "".join(pieces) 
     
    8888    """ 
    8989    Returns a list of pair-wise dependencies from the parameter expressions. 
    90      
     90 
    9191    For example, if p3 = p1+p2, then find_dependencies([p1,p2,p3]) will 
    9292    return [(p3,p1),(p3,p2)].  For base expressions without dependencies, 
     
    110110    """ 
    111111    Find the parameter substitution we need so that expressions can 
    112     be evaluated without having to traverse a chain of  
     112    be evaluated without having to traverse a chain of 
    113113    model.layer.parameter.value 
    114114    """ 
     
    122122    return definition, substitution 
    123123 
    124 def no_constraints():  
     124def no_constraints(): 
    125125    """ 
    126126    This parameter set has no constraints between the parameters. 
     
    163163 
    164164    Parameter names are assumed to contain only _.a-zA-Z0-9#[] 
    165      
     165 
    166166    Both names are provided for inverse functions, e.g., acos and arccos. 
    167167 
    168168    Should try running the function to identify syntax errors before 
    169169    running it in a fit. 
    170      
     170 
    171171    Use help(fn) to see the code generated for the returned function fn. 
    172172    dis.dis(fn) will show the corresponding python vm instructions. 
     
    239239        if independent == emptyset: 
    240240            cycleset = ", ".join(str(s) for s in left) 
    241             raise ValueError,"Cyclic dependencies amongst %s"%cycleset 
     241            raise ValueError("Cyclic dependencies amongst %s"%cycleset) 
    242242 
    243243        # The possibly resolvable items are those that depend on the independents 
     
    267267        n.sort() 
    268268        items = list(items); items.sort() 
    269         raise Exception,"%s expect %s to contain %s for %s"%(msg,n,items,pairs) 
     269        raise ValueError("%s expect %s to contain %s for %s"%(msg,n,items,pairs)) 
    270270    for lo,hi in pairs: 
    271271        if lo in n and hi in n and n.index(lo) >= n.index(hi): 
    272             raise Exception,"%s expect %s before %s in %s for %s"%(msg,lo,hi,n,pairs) 
     272            raise ValueError("%s expect %s before %s in %s for %s"%(msg,lo,hi,n,pairs)) 
    273273 
    274274def test_deps(): 
     
    288288    # Cycle test 
    289289    pairs = [(1,4),(4,3),(4,5),(5,1)] 
    290     try: n = order_dependencies(pairs) 
    291     except ValueError: pass 
    292     else: raise Exception,"test3 expect ValueError exception for %s"%(pairs,) 
     290    try: 
     291        n = order_dependencies(pairs) 
     292    except ValueError: 
     293        pass 
     294    else: 
     295        raise ValueError("test3 expect ValueError exception for %s"%(pairs,)) 
    293296 
    294297    # large test for gross speed check 
     
    308311    import inspect, dis 
    309312    import math 
    310      
     313 
    311314    symtab = {'a.b.x':1, 'a.c':2, 'a.b':3, 'b.x':4} 
    312315    expr = 'a.b.x + sin(4*pi*a.c) + a.b.x/a.b' 
    313      
     316 
    314317    # Check symbol lookup 
    315318    assert _symbols(expr, symtab) == set([1,2,3]) 
     
    357360    expected = 2*math.pi*math.sin(5/.1875) + 6 
    358361    assert p2.value == expected,"Value was %s, not %s"%(p2.value,expected) 
    359      
     362 
    360363    # Check empty dependency set doesn't crash 
    361364    fn = compile_constraints(*world(p1,p3)) 
     
    381384    fn() 
    382385    assert p5.value == 2.07,"Value for %s was %s"%(p5.expression,p5.value) 
    383      
     386 
    384387 
    385388    # Verify that we capture invalid expressions 
    386     for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',  
     389    for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2', 
    387390                 'piddle', 
    388391                 '5; import sys; print "p0wned"', 
  • src/sas/sascalc/fit/pagestate.py

    r0315b63 r9e6aeaf  
    313313 
    314314        if len(self.disp_obj_dict) > 0: 
    315             for k, v in self.disp_obj_dict.iteritems(): 
     315            for k, v in self.disp_obj_dict.items(): 
    316316                obj.disp_obj_dict[k] = v 
    317317        if len(self.disp_cb_dict) > 0: 
    318             for k, v in self.disp_cb_dict.iteritems(): 
     318            for k, v in self.disp_cb_dict.items(): 
    319319                obj.disp_cb_dict[k] = v 
    320320        if len(self.values) > 0: 
    321             for k, v in self.values.iteritems(): 
     321            for k, v in self.values.items(): 
    322322                obj.values[k] = v 
    323323        if len(self.weights) > 0: 
    324             for k, v in self.weights.iteritems(): 
     324            for k, v in self.weights.items(): 
    325325                obj.weights[k] = v 
    326326        obj.enable_smearer = copy.deepcopy(self.enable_smearer) 
     
    347347        obj.version = copy.deepcopy(self.version) 
    348348 
    349         for name, state in self.saved_states.iteritems(): 
     349        for name, state in self.saved_states.items(): 
    350350            copy_name = copy.deepcopy(name) 
    351351            copy_state = state.clone() 
     
    430430        """ 
    431431        p_map = [] 
    432         for name, info in params.iteritems(): 
     432        for name, info in params.items(): 
    433433            if ".fittable" in name or ".std" in name or ".upper" in name or \ 
    434434                            ".lower" in name or ".units" in name: 
     
    475475            formfactor, str_params = convert.convert_model( 
    476476                self.formfactorcombobox, str_pars, False, self.version) 
    477             for key, value in str_params.iteritems(): 
     477            for key, value in str_params.items(): 
    478478                params[key] = value 
    479479 
     
    835835            element = newdoc.createElement(item[0]) 
    836836            value_list = getattr(self, item[1]) 
    837             for key, value in value_list.iteritems(): 
     837            for key, value in value_list.items(): 
    838838                sub_element = newdoc.createElement(key) 
    839839                sub_element.setAttribute('name', str(key)) 
     
    848848            element = newdoc.createElement(tagname) 
    849849            value_list = getattr(self, varname) 
    850             for key, value in value_list.iteritems(): 
     850            for key, value in value_list.items(): 
    851851                sub_element = newdoc.createElement(key) 
    852852                sub_element.setAttribute('name', str(key)) 
     
    950950            msg = "PageState no longer supports non-CanSAS" 
    951951            msg += " format for fitting files" 
    952             raise RuntimeError, msg 
     952            raise RuntimeError(msg) 
    953953 
    954954        if node.get('version'): 
     
    12411241            else: 
    12421242                self.call_back(format=ext) 
    1243                 raise RuntimeError, "%s is not a file" % path 
     1243                raise RuntimeError("%s is not a file" % path) 
    12441244 
    12451245            # Return output consistent with the loader's api 
  • src/sas/sascalc/fit/pluginmodel.py

    r5213d22 r574adc7  
    3535            return self.function(x_val)*self.function(y_val) 
    3636        elif x.__class__.__name__ == 'tuple': 
    37             raise ValueError, "Tuples are not allowed as input to BaseComponent models" 
     37            raise ValueError("Tuples are not allowed as input to BaseComponent models") 
    3838        else: 
    3939            return self.function(x) 
     
    5252            return self.function(x[0])*self.function(x[1]) 
    5353        elif x.__class__.__name__ == 'tuple': 
    54             raise ValueError, "Tuples are not allowed as input to BaseComponent models" 
     54            raise ValueError("Tuples are not allowed as input to BaseComponent models") 
    5555        else: 
    5656            return self.function(x) 
  • src/sas/sascalc/invariant/invariant.py

    rb1f20d1 r574adc7  
    424424        if not issubclass(data.__class__, LoaderData1D): 
    425425            #Process only data that inherited from DataLoader.Data_info.Data1D 
    426             raise ValueError, "Data must be of type DataLoader.Data1D" 
     426            raise ValueError("Data must be of type DataLoader.Data1D") 
    427427        #from copy import deepcopy 
    428428        new_data = (self._scale * data) - self._background 
     
    484484            msg = "Length x and y must be equal" 
    485485            msg += " and greater than 1; got x=%s, y=%s" % (len(data.x), len(data.y)) 
    486             raise ValueError, msg 
     486            raise ValueError(msg) 
    487487        else: 
    488488            # Take care of smeared data 
     
    507507                #iterate between for element different 
    508508                #from the first and the last 
    509                 for i in xrange(1, n - 1): 
     509                for i in range(1, n - 1): 
    510510                    dxi = (data.x[i + 1] - data.x[i - 1]) / 2 
    511511                    total += gx[i] * data.y[i] * dxi 
     
    533533            msg = "Length of data.x and data.y must be equal" 
    534534            msg += " and greater than 1; got x=%s, y=%s" % (len(data.x), len(data.y)) 
    535             raise ValueError, msg 
     535            raise ValueError(msg) 
    536536        else: 
    537537            #Create error for data without dy error 
     
    560560                #iterate between for element different 
    561561                #from the first and the last 
    562                 for i in xrange(1, n - 1): 
     562                for i in range(1, n - 1): 
    563563                    dxi = (data.x[i + 1] - data.x[i - 1]) / 2 
    564564                    total += (gx[i] * dy[i] * dxi) ** 2 
     
    742742        range = range.lower() 
    743743        if range not in ['high', 'low']: 
    744             raise ValueError, "Extrapolation range should be 'high' or 'low'" 
     744            raise ValueError("Extrapolation range should be 'high' or 'low'") 
    745745        function = function.lower() 
    746746        if function not in ['power_law', 'guinier']: 
    747747            msg = "Extrapolation function should be 'guinier' or 'power_law'" 
    748             raise ValueError, msg 
     748            raise ValueError(msg) 
    749749 
    750750        if range == 'high': 
    751751            if function != 'power_law': 
    752752                msg = "Extrapolation only allows a power law at high Q" 
    753                 raise ValueError, msg 
     753                raise ValueError(msg) 
    754754            self._high_extrapolation_npts = npts 
    755755            self._high_extrapolation_power = power 
     
    852852        """ 
    853853        if contrast <= 0: 
    854             raise ValueError, "The contrast parameter must be greater than zero" 
     854            raise ValueError("The contrast parameter must be greater than zero") 
    855855 
    856856        # Make sure Q star is up to date 
     
    859859        if self._qstar <= 0: 
    860860            msg = "Invalid invariant: Invariant Q* must be greater than zero" 
    861             raise RuntimeError, msg 
     861            raise RuntimeError(msg) 
    862862 
    863863        # Compute intermediate constant 
     
    869869        if discrim < 0: 
    870870            msg = "Could not compute the volume fraction: negative discriminant" 
    871             raise RuntimeError, msg 
     871            raise RuntimeError(msg) 
    872872        elif discrim == 0: 
    873873            return 1 / 2 
     
    881881                return volume2 
    882882            msg = "Could not compute the volume fraction: inconsistent results" 
    883             raise RuntimeError, msg 
     883            raise RuntimeError(msg) 
    884884 
    885885    def get_qstar_with_error(self, extrapolation=None): 
  • src/sas/sascalc/pr/c_extensions/Cinvertor.c

    rcb62bd5 rd04ac05  
    5252    invertor_dealloc(&(self->params)); 
    5353 
    54     self->ob_type->tp_free((PyObject*)self); 
     54    Py_TYPE(self)->tp_free((PyObject*)self); 
    5555 
    5656} 
     
    10541054 
    10551055static PyTypeObject CinvertorType = { 
    1056     PyObject_HEAD_INIT(NULL) 
    1057     0,                         /*ob_size*/ 
     1056    //PyObject_HEAD_INIT(NULL) 
     1057    //0,                         /*ob_size*/ 
     1058    PyVarObject_HEAD_INIT(NULL, 0) 
    10581059    "Cinvertor",             /*tp_name*/ 
    10591060    sizeof(Cinvertor),             /*tp_basicsize*/ 
     
    11191120 
    11201121 
    1121 #ifndef PyMODINIT_FUNC  /* declarations for DLL import/export */ 
    1122 #define PyMODINIT_FUNC void 
     1122#define MODULE_DOC "C extension module for inversion to P(r)." 
     1123#define MODULE_NAME "pr_inversion" 
     1124#define MODULE_INIT2 initpr_inversion 
     1125#define MODULE_INIT3 PyInit_pr_inversion 
     1126#define MODULE_METHODS module_methods 
     1127 
     1128/* ==== boilerplate python 2/3 interface bootstrap ==== */ 
     1129 
     1130 
     1131#if defined(WIN32) && !defined(__MINGW32__) 
     1132    #define DLL_EXPORT __declspec(dllexport) 
     1133#else 
     1134    #define DLL_EXPORT 
    11231135#endif 
    1124 PyMODINIT_FUNC 
    1125 initpr_inversion(void) 
    1126 { 
    1127     PyObject* m; 
    1128  
    1129     m = Py_InitModule3("pr_inversion", module_methods, 
    1130                        "C extension module for inversion to P(r)."); 
    1131  
    1132     addCinvertor(m); 
    1133 } 
     1136 
     1137#if PY_MAJOR_VERSION >= 3 
     1138 
     1139  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT3(void) 
     1140  { 
     1141    static struct PyModuleDef moduledef = { 
     1142      PyModuleDef_HEAD_INIT, 
     1143      MODULE_NAME,         /* m_name */ 
     1144      MODULE_DOC,          /* m_doc */ 
     1145      -1,                  /* m_size */ 
     1146      MODULE_METHODS,      /* m_methods */ 
     1147      NULL,                /* m_reload */ 
     1148      NULL,                /* m_traverse */ 
     1149      NULL,                /* m_clear */ 
     1150      NULL,                /* m_free */ 
     1151    }; 
     1152        PyObject* m = PyModule_Create(&moduledef); 
     1153        addCinvertor(m); 
     1154        return m; 
     1155  } 
     1156 
     1157#else /* !PY_MAJOR_VERSION >= 3 */ 
     1158 
     1159  DLL_EXPORT PyMODINIT_FUNC MODULE_INIT2(void) 
     1160  { 
     1161    PyObject* m = Py_InitModule4(MODULE_NAME, 
     1162                 MODULE_METHODS, 
     1163                 MODULE_DOC, 
     1164                 0, 
     1165                 PYTHON_API_VERSION 
     1166                 ); 
     1167        addCinvertor(m); 
     1168  } 
     1169 
     1170#endif /* !PY_MAJOR_VERSION >= 3 */ 
  • src/sas/sascalc/pr/fit/AbstractFitEngine.py

    r50fcb09 r574adc7  
    251251            msg = "FitData1D: invalid error array " 
    252252            msg += "%d <> %d" % (np.shape(self.dy), np.size(fx)) 
    253             raise RuntimeError, msg 
     253            raise RuntimeError(msg) 
    254254        return (self.y[self.idx] - fx[self.idx]) / self.dy[self.idx], fx[self.idx] 
    255255 
  • src/sas/sascalc/pr/fit/Loader.py

    ra1b8fee r574adc7  
    1818        self.dy = dy 
    1919        self.filename = None 
    20          
     20 
    2121    def set_filename(self, path=None): 
    2222        """ 
    23         Store path into a variable.If the user doesn't give  
     23        Store path into a variable.If the user doesn't give 
    2424        a path as a parameter a pop-up 
    2525        window appears to select the file. 
    26          
     26 
    2727        :param path: the path given by the user 
    28          
     28 
    2929        """ 
    3030        self.filename = path 
    31         
     31 
    3232    def get_filename(self): 
    3333        """ return the file's path""" 
    3434        return self.filename 
    35      
     35 
    3636    def set_values(self): 
    3737        """ Store the values loaded from file in local variables""" 
     
    4242            self.x = [] 
    4343            self.y = [] 
    44             self.dx = []  
     44            self.dx = [] 
    4545            self.dy = [] 
    4646            for line in lines: 
     
    5050                    y = float(toks[1]) 
    5151                    dy = float(toks[2]) 
    52                      
     52 
    5353                    self.x.append(x) 
    5454                    self.y.append(y) 
     
    5959            # Sanity check 
    6060            if not len(self.x) == len(self.dx): 
    61                 raise ValueError, "x and dx have different length" 
     61                raise ValueError("x and dx have different length") 
    6262            if not len(self.y) == len(self.dy): 
    63                 raise ValueError, "y and dy have different length" 
    64              
    65              
     63                raise ValueError("y and dy have different length") 
     64 
     65 
    6666    def get_values(self): 
    6767        """ Return x, y, dx, dy""" 
    6868        return self.x, self.y, self.dx, self.dy 
    69      
     69 
    7070    def load_data(self, data): 
    7171        """ Return plottable""" 
     
    7777        #Load its View class 
    7878        #plottable.reset_view() 
    79         
    80      
    81 if __name__ == "__main__":  
     79 
     80 
     81if __name__ == "__main__": 
    8282    load = Load() 
    8383    load.set_filename("testdata_line.txt") 
    84     print(load.get_filename())  
     84    print(load.get_filename()) 
    8585    load.set_values() 
    8686    print(load.get_values()) 
    87      
    88              
     87 
  • src/sas/sascalc/pr/fit/expression.py

    ra1b8fee r574adc7  
    5959    occur multiple times.  The return value is a set with the elements in 
    6060    no particular order. 
    61      
     61 
    6262    This is the first step in computing a dependency graph. 
    6363    """ 
     
    8181        offset = end 
    8282    pieces.append(expr[offset:]) 
    83      
     83 
    8484    # Join the pieces and return them 
    8585    return "".join(pieces) 
     
    8888    """ 
    8989    Returns a list of pair-wise dependencies from the parameter expressions. 
    90      
     90 
    9191    For example, if p3 = p1+p2, then find_dependencies([p1,p2,p3]) will 
    9292    return [(p3,p1),(p3,p2)].  For base expressions without dependencies, 
     
    110110    """ 
    111111    Find the parameter substitution we need so that expressions can 
    112     be evaluated without having to traverse a chain of  
     112    be evaluated without having to traverse a chain of 
    113113    model.layer.parameter.value 
    114114    """ 
     
    122122    return definition, substitution 
    123123 
    124 def no_constraints():  
     124def no_constraints(): 
    125125    """ 
    126126    This parameter set has no constraints between the parameters. 
     
    163163 
    164164    Parameter names are assumed to contain only _.a-zA-Z0-9#[] 
    165      
     165 
    166166    Both names are provided for inverse functions, e.g., acos and arccos. 
    167167 
    168168    Should try running the function to identify syntax errors before 
    169169    running it in a fit. 
    170      
     170 
    171171    Use help(fn) to see the code generated for the returned function fn. 
    172172    dis.dis(fn) will show the corresponding python vm instructions. 
     
    239239        if independent == emptyset: 
    240240            cycleset = ", ".join(str(s) for s in left) 
    241             raise ValueError,"Cyclic dependencies amongst %s"%cycleset 
     241            raise ValueError("Cyclic dependencies amongst %s"%cycleset) 
    242242 
    243243        # The possibly resolvable items are those that depend on the independents 
     
    267267        n.sort() 
    268268        items = list(items); items.sort() 
    269         raise Exception,"%s expect %s to contain %s for %s"%(msg,n,items,pairs) 
     269        raise ValueError("%s expect %s to contain %s for %s"%(msg,n,items,pairs)) 
    270270    for lo,hi in pairs: 
    271271        if lo in n and hi in n and n.index(lo) >= n.index(hi): 
    272             raise Exception,"%s expect %s before %s in %s for %s"%(msg,lo,hi,n,pairs) 
     272            raise ValueError("%s expect %s before %s in %s for %s"%(msg,lo,hi,n,pairs)) 
    273273 
    274274def test_deps(): 
     
    288288    # Cycle test 
    289289    pairs = [(1,4),(4,3),(4,5),(5,1)] 
    290     try: n = order_dependencies(pairs) 
    291     except ValueError: pass 
    292     else: raise Exception,"test3 expect ValueError exception for %s"%(pairs,) 
     290    try: 
     291        n = order_dependencies(pairs) 
     292    except ValueError: 
     293        pass 
     294    else: 
     295        raise Exception("test3 expect ValueError exception for %s"%(pairs,)) 
    293296 
    294297    # large test for gross speed check 
     
    308311    import inspect, dis 
    309312    import math 
    310      
     313 
    311314    symtab = {'a.b.x':1, 'a.c':2, 'a.b':3, 'b.x':4} 
    312315    expr = 'a.b.x + sin(4*pi*a.c) + a.b.x/a.b' 
    313      
     316 
    314317    # Check symbol lookup 
    315318    assert _symbols(expr, symtab) == set([1,2,3]) 
     
    357360    expected = 2*math.pi*math.sin(5/.1875) + 6 
    358361    assert p2.value == expected,"Value was %s, not %s"%(p2.value,expected) 
    359      
     362 
    360363    # Check empty dependency set doesn't crash 
    361364    fn = compile_constraints(*world(p1,p3)) 
     
    381384    fn() 
    382385    assert p5.value == 2.07,"Value for %s was %s"%(p5.expression,p5.value) 
    383      
     386 
    384387 
    385388    # Verify that we capture invalid expressions 
    386     for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2',  
     389    for expr in ['G4.cage', 'M0.cage', 'M1.G1 + *2', 
    387390                 'piddle', 
    388391                 '5; import sys; print "p0wned"', 
  • src/sas/sascalc/pr/invertor.py

    rcb62bd5 rd04ac05  
    148148                msg = "Invertor: one of your q-values is zero. " 
    149149                msg += "Delete that entry before proceeding" 
    150                 raise ValueError, msg 
     150                raise ValueError(msg) 
    151151            return self.set_x(value) 
    152152        elif name == 'y': 
     
    159159                msg = "Invertor: d_max must be greater than zero." 
    160160                msg += "Correct that entry before proceeding" 
    161                 raise ValueError, msg 
     161                raise ValueError(msg) 
    162162            return self.set_dmax(value) 
    163163        elif name == 'q_min': 
     
    181181                return self.set_est_bck(0) 
    182182            else: 
    183                 raise ValueError, "Invertor: est_bck can only be True or False" 
     183                raise ValueError("Invertor: est_bck can only be True or False") 
    184184 
    185185        return Cinvertor.__setattr__(self, name, value) 
     
    331331        if self.is_valid() <= 0: 
    332332            msg = "Invertor.invert: Data array are of different length" 
    333             raise RuntimeError, msg 
     333            raise RuntimeError(msg) 
    334334 
    335335        p = np.ones(nfunc) 
     
    364364        if self.is_valid() <= 0: 
    365365            msg = "Invertor.invert: Data arrays are of different length" 
    366             raise RuntimeError, msg 
     366            raise RuntimeError(msg) 
    367367 
    368368        p = np.ones(nfunc) 
     
    448448        if self.is_valid() < 0: 
    449449            msg = "Invertor: invalid data; incompatible data lengths." 
    450             raise RuntimeError, msg 
     450            raise RuntimeError(msg) 
    451451 
    452452        self.nfunc = nfunc 
     
    472472        try: 
    473473            self._get_matrix(nfunc, nq, a, b) 
    474         except: 
    475             raise RuntimeError, "Invertor: could not invert I(Q)\n  %s" % sys.exc_value 
     474        except Exception as exc: 
     475            raise RuntimeError("Invertor: could not invert I(Q)\n  %s" % str(exc)) 
    476476 
    477477        # Perform the inversion (least square fit) 
     
    756756            except: 
    757757                msg = "Invertor.from_file: corrupted file\n%s" % sys.exc_value 
    758                 raise RuntimeError, msg 
     758                raise RuntimeError(msg) 
    759759        else: 
    760760            msg = "Invertor.from_file: '%s' is not a file" % str(path) 
    761             raise RuntimeError, msg 
     761            raise RuntimeError(msg) 
  • src/sas/sasgui/guiframe/config.py

    rb963b20 r1efbc190  
    145145UPDATE_TIMEOUT = 2 
    146146 
    147 # Time out for updating sasview 
    148 UPDATE_TIMEOUT = 2 
    149  
    150147def printEVT(message): 
    151148    if __EVT_DEBUG__: 
  • src/sas/sasgui/perspectives/fitting/simfitpage.py

    r24d9e84 r0a3c740  
    174174                save_id = self._format_id(save_id) 
    175175                if save_id == model_id: 
    176                     model_map[saved_model.pop('fit_page_source')] = \ 
    177                         model[3].name 
    178                     check = bool(saved_model.pop('checked')) 
    179                     self.model_list[i][0].SetValue(check) 
    180176                    inter_id = str(i)*5 
    181177                    init_map[saved_model.pop('fit_page_source')] = inter_id 
  • src/sas/sasview/sasview.py

    rb277220 r0225a3f  
    1818import logging 
    1919 
    20 reload(sys) 
    21 sys.setdefaultencoding("iso-8859-1") 
     20try: 
     21    reload(sys) 
     22    sys.setdefaultencoding("iso-8859-1") 
     23except NameError: 
     24    # On python 3 sys.setdefaultencoding does nothing, so pass. 
     25    # We know we are in python 3 at this point since reload is no longer in 
     26    # builtins, but instead has been moved to importlib, hence the NameError. 
     27    pass 
    2228 
    2329import sas 
     
    224230    setup_mpl(backend='WXAgg' if os.name == 'nt' else None) 
    225231    setup_sasmodels() 
    226     if len(sys.argv) == 1: 
     232    if len(sys.argv) == 1 or sys.argv[1] == '-i': 
    227233        # Run sasview as an interactive python interpreter 
    228234        try: 
     
    233239            import code 
    234240            code.interact(local={'exit': sys.exit}) 
     241    elif sys.argv[1] == '-c': 
     242        exec(sys.argv[2]) 
    235243    else: 
    236         # Run sasview as a python script interpreter 
    237         ## Run sasview as an interactive python interpreter 
    238         # if sys.argv[1] == "-i": 
    239         #    sys.argv = ["ipython", "--pylab"] 
    240         #    from IPython import start_ipython 
    241         #    sys.exit(start_ipython()) 
    242244        thing_to_run = sys.argv[1] 
    243245        sys.argv = sys.argv[1:] 
  • test/run_one.py

    • Property mode changed from 100644 to 100755
  • test/sascalculator/test/utest_sas_gen.py

    r959eb01 r1d014cb  
    1010 
    1111class sas_gen_test(unittest.TestCase): 
    12      
     12 
    1313    def setUp(self): 
    1414        self.sldloader = sas_gen.SLDReader() 
    1515        self.pdbloader = sas_gen.PDBReader() 
    1616        self.omfloader = sas_gen.OMFReader() 
    17          
     17 
    1818    def test_sldreader(self): 
    1919        """ 
    20         Test .sld file loaded  
     20        Test .sld file loaded 
    2121        """ 
    2222        f = self.sldloader.read("sld_file.sld") 
     
    2424        self.assertEqual(f.pos_y[0], -13.5) 
    2525        self.assertEqual(f.pos_z[0], -13.5) 
    26          
     26 
    2727    def test_pdbreader(self): 
    2828        """ 
    29         Test .pdb file loaded  
     29        Test .pdb file loaded 
    3030        """ 
    3131        f = self.pdbloader.read("c60.pdb") 
     
    3333        self.assertEqual(f.pos_y[0], -1.008) 
    3434        self.assertEqual(f.pos_z[0], 3.326) 
    35          
     35 
    3636    def test_omfreader(self): 
    3737        """ 
    38         Test .omf file loaded  
     38        Test .omf file loaded 
    3939        """ 
    4040        f = self.omfloader.read("A_Raw_Example-1.omf") 
  • test/sascalculator/test/utest_sld.py

    r959eb01 ra50da82  
    1010from periodictable.constants import avogadro_number 
    1111from  periodictable.nsf import neutron_scattering, neutron_sld 
    12         
     12 
    1313 
    1414def calculate_xray_sld(element, density, molecule_formula): 
     
    1919    element_formula = formula(str(element)) 
    2020    if len(element_formula.atoms) != 1: 
    21         return  
    22     element = element_formula.atoms.keys()[0]  
     21        return 
     22    element = next(iter(element_formula.atoms))  # only one element... 
    2323    energy = xray_energy(element.K_alpha) 
    2424    atom = molecule_formula.atoms 
     
    3030    Sld calculator test for H2O 
    3131    """ 
    32      
     32 
    3333    def setUp(self): 
    3434        """Inititialze variables""" 
    35          
     35 
    3636        self.compound = "H2O" 
    3737        self.density = 1.0 
    3838        self.wavelength = 6.0 
    3939        self.sld_formula = formula(self.compound, density=self.density) 
    40      
     40 
    4141    def test_neutron_sld(self): 
    4242        """ 
    43         test sld  
     43        test sld 
    4444        """ 
    4545        #Compute incoherence , absorption, and incoherence 
    4646        (sld_real,sld_im,sld_inc), (coh,abs,incoh), length = neutron_scattering(self.compound, 
    47                                        density=self.density, wavelength=self.wavelength)  
     47                                       density=self.density, wavelength=self.wavelength) 
    4848        cu_real, cu_im = calculate_xray_sld(element="Cu", density=self.density, 
    4949                                  molecule_formula=self.sld_formula) 
    5050        mo_real, mo_im = calculate_xray_sld(element="Mo", density=self.density, 
    5151                                  molecule_formula=self.sld_formula) 
    52         #test sld  
     52        #test sld 
    5353        self.assertAlmostEquals(sld_real * _SCALE, -5.6e-7, 1) 
    5454        self.assertAlmostEquals(sld_im * _SCALE, 0) 
     
    6464        self.assertAlmostEquals(mo_real * _SCALE, 9.43e-6) 
    6565        self.assertAlmostEquals(mo_im * _SCALE, 5.65e-7,1) 
    66      
    67      
     66 
     67 
    6868class TestD2O(unittest.TestCase): 
    6969    """ 
    7070    Sld calculator test for D2O 
    7171    """ 
    72      
     72 
    7373    def setUp(self): 
    7474        """Inititialze variables""" 
    75          
     75 
    7676        self.compound = "D2O" 
    7777        self.density = 1.1 
    7878        self.wavelength = 6.0 
    7979        self.sld_formula = formula(self.compound, density=self.density) 
    80      
     80 
    8181    def test_neutron_sld(self): 
    8282        """ 
    83         test sld  
     83        test sld 
    8484        """ 
    8585        #Compute incoherence , absorption, and incoherence 
    8686        (sld_real,sld_im,sld_inc), (coh,abs,incoh), length = neutron_scattering(self.compound, 
    87                                        density=self.density, wavelength=self.wavelength)  
     87                                       density=self.density, wavelength=self.wavelength) 
    8888        cu_real, cu_im = calculate_xray_sld(element="Cu", density=self.density, 
    8989                                  molecule_formula=self.sld_formula) 
    9090        mo_real, mo_im = calculate_xray_sld(element="Mo", density=self.density, 
    9191                                  molecule_formula=self.sld_formula) 
    92         #test sld  
     92        #test sld 
    9393        self.assertAlmostEquals(sld_real * _SCALE, 6.33e-6, 1) 
    9494        self.assertAlmostEquals(sld_im * _SCALE, 0) 
     
    104104        self.assertAlmostEquals(mo_real * _SCALE, 9.33e-6) 
    105105        self.assertAlmostEquals(mo_im * _SCALE, 5.59e-9,1) 
    106      
    107          
     106 
     107 
    108108class TestCd(unittest.TestCase): 
    109109    """ 
    110110    Sld calculator test for Cd 
    111111    """ 
    112      
     112 
    113113    def setUp(self): 
    114114        """Inititialze variables""" 
     
    118118        self.wavelength = 6.0 
    119119        self.sld_formula = formula(self.compound, density=self.density) 
    120         
     120 
    121121    def test_neutron_sld(self): 
    122122        """ 
    123         test sld  
     123        test sld 
    124124        """ 
    125125        #Compute incoherence , absorption, and incoherence 
    126126        (sld_real,sld_im,sld_inc), (coh,abs,incoh), length = neutron_scattering(self.compound, 
    127                                 density=self.density, wavelength=self.wavelength)  
     127                                density=self.density, wavelength=self.wavelength) 
    128128        cu_real, cu_im = calculate_xray_sld(element="Cu", density=self.density, 
    129129                                  molecule_formula=self.sld_formula) 
    130130        mo_real, mo_im = calculate_xray_sld(element="Mo", density=self.density, 
    131131                                  molecule_formula=self.sld_formula) 
    132         #test sld  
     132        #test sld 
    133133        self.assertAlmostEquals(sld_real * _SCALE, 1.04e-6, 1) 
    134134        self.assertAlmostEquals(sld_im * _SCALE, -1.5e-7, 1) 
     
    144144        self.assertAlmostEquals(mo_real * _SCALE, 2.84e-5, 1) 
    145145        self.assertAlmostEquals(mo_im * _SCALE, 7.26e-7,1) 
    146    
     146 
    147147if __name__ == '__main__': 
    148148    unittest.main() 
  • test/sasdataloader/test/utest_abs_reader.py

    rae69c690 r574adc7  
    224224                _found2 = True 
    225225 
    226         if _found1 == False or _found2 == False: 
    227             raise RuntimeError, "Could not find all data %s %s" % (_found1, _found2) 
     226        if not _found1 or not _found2: 
     227            raise RuntimeError("Could not find all data %s %s" 
     228                               % (_found1, _found2)) 
    228229 
    229230        # Detector 
     
    269270                    _found_term1 = True 
    270271 
    271         if _found_term1 == False or _found_term2 == False: 
    272             raise RuntimeError, "Could not find all process terms %s %s" % (_found_term1, _found_term2) 
     272        if not _found_term1 or not _found_term2: 
     273            raise RuntimeError("Could not find all process terms %s %s" 
     274                               % (_found_term1, _found_term2)) 
    273275 
    274276    def test_writer(self): 
  • test/sasdataloader/test/utest_cansas.py

    r17e257b5 rf00072f  
    22    Unit tests for the new recursive cansas reader 
    33""" 
     4import os 
     5import sys 
     6import unittest 
     7import logging 
     8import warnings 
     9if sys.version_info[0] >= 3: 
     10    from io import StringIO 
     11else: 
     12    from StringIO import StringIO 
     13 
     14from lxml import etree 
     15from lxml.etree import XMLSyntaxError 
     16from xml.dom import minidom 
     17 
    418import sas.sascalc.dataloader.readers.cansas_reader as cansas 
     19from sas.sascalc.dataloader.file_reader_base_class import decode 
    520from sas.sascalc.dataloader.loader import Loader 
    621from sas.sascalc.dataloader.data_info import Data1D, Data2D 
     
    823from sas.sascalc.dataloader.readers.cansas_reader import Reader 
    924from sas.sascalc.dataloader.readers.cansas_constants import CansasConstants 
    10  
    11 import os 
    12 import sys 
    13 import urllib2 
    14 import StringIO 
    15 import pylint as pylint 
    16 import unittest 
    17 import numpy as np 
    18 import logging 
    19 import warnings 
    20  
    21 from lxml import etree 
    22 from lxml.etree import XMLSyntaxError 
    23 from xml.dom import minidom 
    2425 
    2526logger = logging.getLogger(__name__) 
     
    6263        Should fail gracefully and send a message to logger.info() 
    6364        """ 
    64         invalid = StringIO.StringIO('<a><c></b></a>') 
     65        invalid = StringIO('<a><c></b></a>') 
    6566        self.assertRaises(XMLSyntaxError, lambda: XMLreader(invalid)) 
    6667 
     
    7475        string += "\t</xsd:complexType>\n" 
    7576        string += "</xsd:schema>" 
    76         f = StringIO.StringIO(string) 
     77        f = StringIO(string) 
    7778        xmlschema_doc = etree.parse(f) 
    7879        xmlschema = etree.XMLSchema(xmlschema_doc) 
    79         valid = etree.parse(StringIO.StringIO('<a><b></b></a>')) 
    80         invalid = etree.parse(StringIO.StringIO('<a><c></c></a>')) 
     80        valid = etree.parse(StringIO('<a><b></b></a>')) 
     81        invalid = etree.parse(StringIO('<a><c></c></a>')) 
    8182        self.assertTrue(xmlschema.validate(valid)) 
    8283        self.assertFalse(xmlschema.validate(invalid)) 
     
    214215            # find the processing instructions and make into a dictionary 
    215216            dic = self.get_processing_instructions(reader) 
    216             self.assertTrue(dic == {'xml-stylesheet': \ 
    217                                     'type="text/xsl" href="cansas1d.xsl" '}) 
     217            self.assertEqual(dic, {'xml-stylesheet': 
     218                                   'type="text/xsl" href="cansas1d.xsl" '}) 
    218219 
    219220            xml = "<test><a><b><c></c></b></a></test>" 
     
    238239            attr = {} 
    239240            pi_name = "" 
    240             pi_string = etree.tostring(pi) 
     241            pi_string = decode(etree.tostring(pi)) 
    241242            if isinstance(pi_string, str): 
    242243                pi_string = pi_string.replace("<?", "").replace("?>", "") 
     
    309310 
    310311if __name__ == '__main__': 
    311     unittest.main()     
     312    unittest.main() 
  • test/sasrealspace/test/utest_oriented.py

    raaf5e49 r1cdbcd8  
    99# Disable "missing docstring" complaint 
    1010# pylint: disable-msg=C0111 
    11 # Disable "too many methods" complaint  
    12 # pylint: disable-msg=R0904  
    13 # Disable "could be a function" complaint  
     11# Disable "too many methods" complaint 
     12# pylint: disable-msg=R0904 
     13# Disable "could be a function" complaint 
    1414# pylint: disable-msg=R0201 
    1515# pylint: disable-msg=W0702 
    1616 
    17 try: 
    18     import VolumeCanvas 
    19     print("Testing local version") 
    20 except: 
    21     print(sys.exc_value) 
    22     #testing the version that is working on 
    23     print("Testing installed version") 
    24     import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
    25   
     17from sasmodels.sasview_model import _make_standard_model 
     18EllipsoidModel = _make_standard_model('ellipsoid') 
     19SphereModel = _make_standard_model('sphere') 
     20CylinderModel = _make_standard_model('cylinder') 
     21CoreShellModel = _make_standard_model('core_shell_sphere') 
     22 
     23import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
     24 
     25 
    2626 
    2727class TestSphere(unittest.TestCase): 
    2828    """ Tests for oriented (2D) systems """ 
    29          
     29 
    3030    def setUp(self): 
    3131        """ 
    3232            Set up canvas 
    3333        """ 
    34         from sas.models.SphereModel import SphereModel 
    3534        self.model = VolumeCanvas.VolumeCanvas() 
    36      
     35 
    3736        handle = self.model.add('sphere') 
    38          
     37 
    3938        radius = 10 
    4039        density = .1 
    41          
     40 
    4241        ana = SphereModel() 
    4342        ana.setParam('scale', 1.0) 
    44         ana.setParam('contrast', 1.0) 
    4543        ana.setParam('background', 0.0) 
     44        ana.setParam('sld', 1.0) 
     45        ana.setParam('sld_solvent', 0.0) 
    4646        ana.setParam('radius', radius) 
    4747        self.ana = ana 
    48          
     48 
    4949        self.model.setParam('lores_density', density) 
     50        self.model.setParam('scale' , 1.0) 
     51        self.model.setParam('background' , 0.0) 
     52        self.model.setParam('%s.contrast' % handle, 1.0) 
    5053        self.model.setParam('%s.radius' % handle, radius) 
    51         self.model.setParam('scale' , 1.0) 
    52         self.model.setParam('%s.contrast' % handle, 1.0) 
    53         self.model.setParam('background' , 0.0) 
    54          
    55          
     54 
     55 
    5656    def testdefault(self): 
    5757        """ Testing sphere """ 
     
    6060        sim_val = self.model.getIq2D(0.1, 0.1) 
    6161        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.1 ) 
    62          
     62 
    6363class TestCylinderAddObject(unittest.TestCase): 
    6464    """ Tests for oriented (2D) systems """ 
    65          
     65 
    6666    def setUp(self): 
    6767        """ Set up cylinder model """ 
    68         from sas.models.CylinderModel import CylinderModel 
    6968        radius = 5 
    7069        length = 40 
    7170        density = 20 
    72      
     71 
    7372        # Analytical model 
    7473        self.ana = CylinderModel() 
    7574        self.ana.setParam('scale', 1.0) 
    76         self.ana.setParam('contrast', 1.0) 
    7775        self.ana.setParam('background', 0.0) 
     76        self.ana.setParam('sld', 1.0) 
     77        self.ana.setParam('sld_solvent', 0.0) 
    7878        self.ana.setParam('radius', radius) 
    7979        self.ana.setParam('length', length) 
    80      
     80 
    8181        # Simulation model 
    8282        self.model = VolumeCanvas.VolumeCanvas() 
     
    8484        self.handle = self.model.addObject(cyl) 
    8585        self.model.setParam('lores_density', density) 
     86        self.model.setParam('scale' , 1.0) 
     87        self.model.setParam('background' , 0.0) 
     88        self.model.setParam('%s.contrast' % self.handle, 1.0) 
    8689        self.model.setParam('%s.radius' % self.handle, radius) 
    8790        self.model.setParam('%s.length' % self.handle, length) 
    88         self.model.setParam('scale' , 1.0) 
    89         self.model.setParam('%s.contrast' % self.handle, 1.0) 
    90         self.model.setParam('background' , 0.0) 
    91      
     91 
    9292    def testalongY(self): 
    9393        """ Testing cylinder along Y axis """ 
    94         self.ana.setParam('cyl_theta', math.pi/2.0) 
    95         self.ana.setParam('cyl_phi', math.pi/2.0) 
    96          
     94        self.ana.setParam('theta', math.pi/2.0) 
     95        self.ana.setParam('phi', math.pi/2.0) 
     96 
    9797        self.model.setParam('%s.orientation' % self.handle, [0,0,0]) 
    98          
    99         ana_val = self.ana.runXY([0.1, 0.2]) 
    100         sim_val = self.model.getIq2D(0.1, 0.2) 
    101         #print ana_val, sim_val, sim_val/ana_val 
    102          
    103         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    104          
    105          
     98 
     99        ana_val = self.ana.runXY([0.1, 0.2]) 
     100        sim_val = self.model.getIq2D(0.1, 0.2) 
     101        #print ana_val, sim_val, sim_val/ana_val 
     102 
     103        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     104 
     105 
    106106class TestCylinder(unittest.TestCase): 
    107107    """ Tests for oriented (2D) systems """ 
    108          
     108 
    109109    def setUp(self): 
    110110        """ Set up cylinder model """ 
    111         from sas.models.CylinderModel import CylinderModel 
    112111        radius = 5 
    113112        length = 40 
    114113        density = 20 
    115      
     114 
    116115        # Analytical model 
    117116        self.ana = CylinderModel() 
    118117        self.ana.setParam('scale', 1.0) 
    119         self.ana.setParam('contrast', 1.0) 
    120118        self.ana.setParam('background', 0.0) 
     119        self.ana.setParam('sld', 1.0) 
     120        self.ana.setParam('sld_solvent', 0.0) 
    121121        self.ana.setParam('radius', radius) 
    122122        self.ana.setParam('length', length) 
    123      
     123 
    124124        # Simulation model 
    125125        self.model = VolumeCanvas.VolumeCanvas() 
    126126        self.handle = self.model.add('cylinder') 
    127127        self.model.setParam('lores_density', density) 
     128        self.model.setParam('scale' , 1.0) 
     129        self.model.setParam('background' , 0.0) 
    128130        self.model.setParam('%s.radius' % self.handle, radius) 
    129131        self.model.setParam('%s.length' % self.handle, length) 
    130         self.model.setParam('scale' , 1.0) 
    131132        self.model.setParam('%s.contrast' % self.handle, 1.0) 
    132         self.model.setParam('background' , 0.0) 
    133      
     133 
    134134    def testalongY(self): 
    135135        """ Testing cylinder along Y axis """ 
    136         self.ana.setParam('cyl_theta', math.pi/2.0) 
    137         self.ana.setParam('cyl_phi', math.pi/2.0) 
    138          
     136        self.ana.setParam('theta', math.pi/2.0) 
     137        self.ana.setParam('phi', math.pi/2.0) 
     138 
    139139        self.model.setParam('%s.orientation' % self.handle, [0,0,0]) 
    140          
    141         ana_val = self.ana.runXY([0.1, 0.2]) 
    142         sim_val = self.model.getIq2D(0.1, 0.2) 
    143         #print ana_val, sim_val, sim_val/ana_val 
    144          
    145         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    146          
     140 
     141        ana_val = self.ana.runXY([0.1, 0.2]) 
     142        sim_val = self.model.getIq2D(0.1, 0.2) 
     143        #print ana_val, sim_val, sim_val/ana_val 
     144 
     145        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     146 
    147147    def testalongZ(self): 
    148148        """ Testing cylinder along Z axis """ 
    149         self.ana.setParam('cyl_theta', 0) 
    150         self.ana.setParam('cyl_phi', 0) 
    151          
     149        self.ana.setParam('theta', 0) 
     150        self.ana.setParam('phi', 0) 
     151 
    152152        self.model.setParam('%s.orientation' % self.handle, [90,0,0]) 
    153          
    154         ana_val = self.ana.runXY([0.1, 0.2]) 
    155         sim_val = self.model.getIq2D(0.1, 0.2) 
    156         #print ana_val, sim_val, sim_val/ana_val 
    157          
    158         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    159          
     153 
     154        ana_val = self.ana.runXY([0.1, 0.2]) 
     155        sim_val = self.model.getIq2D(0.1, 0.2) 
     156        #print ana_val, sim_val, sim_val/ana_val 
     157 
     158        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     159 
    160160    def testalongX(self): 
    161161        """ Testing cylinder along X axis """ 
    162         self.ana.setParam('cyl_theta', 1.57) 
    163         self.ana.setParam('cyl_phi', 0) 
    164          
     162        self.ana.setParam('theta', 1.57) 
     163        self.ana.setParam('phi', 0) 
     164 
    165165        self.model.setParam('%s.orientation' % self.handle, [0,0,90]) 
    166          
    167         ana_val = self.ana.runXY([0.1, 0.2]) 
    168         sim_val = self.model.getIq2D(0.1, 0.2) 
    169         #print ana_val, sim_val, sim_val/ana_val 
    170          
    171         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    172          
     166 
     167        ana_val = self.ana.runXY([0.1, 0.2]) 
     168        sim_val = self.model.getIq2D(0.1, 0.2) 
     169        #print ana_val, sim_val, sim_val/ana_val 
     170 
     171        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     172 
    173173class TestEllipsoid(unittest.TestCase): 
    174174    """ Tests for oriented (2D) systems """ 
    175          
     175 
    176176    def setUp(self): 
    177177        """ Set up ellipsoid """ 
    178         from sas.models.EllipsoidModel import EllipsoidModel 
    179          
     178 
    180179        radius_a = 60 
    181180        radius_b = 10 
    182181        density = 30 
    183          
     182 
    184183        self.ana = EllipsoidModel() 
    185184        self.ana.setParam('scale', 1.0) 
    186         self.ana.setParam('contrast', 1.0) 
    187185        self.ana.setParam('background', 0.0) 
    188         self.ana.setParam('radius_a', radius_a) 
    189         self.ana.setParam('radius_b', radius_b) 
     186        self.ana.setParam('sld', 1.0) 
     187        self.ana.setParam('sld_solvent', 0.0) 
     188        self.ana.setParam('radius_polar', radius_a) 
     189        self.ana.setParam('radius_equatorial', radius_b) 
    190190        # Default orientation is there=1.57, phi=0 
    191191        # Radius_a is along the x direction 
    192         
     192 
    193193        canvas = VolumeCanvas.VolumeCanvas() 
     194        self.handle = canvas.add('ellipsoid') 
    194195        canvas.setParam('lores_density', density) 
    195         self.handle = canvas.add('ellipsoid') 
     196        canvas.setParam('scale' , 1.0) 
     197        canvas.setParam('background' , 0.0) 
    196198        canvas.setParam('%s.radius_x' % self.handle, radius_a) 
    197199        canvas.setParam('%s.radius_y' % self.handle, radius_b) 
    198200        canvas.setParam('%s.radius_z' % self.handle, radius_b) 
    199         canvas.setParam('scale' , 1.0) 
    200201        canvas.setParam('%s.contrast' % self.handle, 1.0) 
    201         canvas.setParam('background' , 0.0) 
    202         self.canvas = canvas         
     202        self.canvas = canvas 
    203203 
    204204    def testalongX(self): 
    205205        """ Testing ellipsoid along X """ 
    206         self.ana.setParam('axis_theta', 1.57) 
    207         self.ana.setParam('axis_phi', 0) 
    208          
     206        self.ana.setParam('theta', 1.57) 
     207        self.ana.setParam('phi', 0) 
     208 
    209209        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0]) 
    210          
     210 
    211211        ana_val = self.ana.runXY([0.1, 0.2]) 
    212212        sim_val = self.canvas.getIq2D(0.1, 0.2) 
    213213        #print ana_val, sim_val, sim_val/ana_val 
    214          
     214 
    215215        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    216216 
    217217    def testalongZ(self): 
    218218        """ Testing ellipsoid along Z """ 
    219         self.ana.setParam('axis_theta', 0) 
    220         self.ana.setParam('axis_phi', 0) 
    221          
     219        self.ana.setParam('theta', 0) 
     220        self.ana.setParam('phi', 0) 
     221 
    222222        self.canvas.setParam('%s.orientation' % self.handle, [0,90,0]) 
    223          
     223 
    224224        ana_val = self.ana.runXY([0.1, 0.2]) 
    225225        sim_val = self.canvas.getIq2D(0.1, 0.2) 
    226226        #print ana_val, sim_val, sim_val/ana_val 
    227          
     227 
    228228        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    229229 
    230230    def testalongY(self): 
    231231        """ Testing ellipsoid along Y """ 
    232         self.ana.setParam('axis_theta', math.pi/2.0) 
    233         self.ana.setParam('axis_phi', math.pi/2.0) 
    234          
     232        self.ana.setParam('theta', math.pi/2.0) 
     233        self.ana.setParam('phi', math.pi/2.0) 
     234 
    235235        self.canvas.setParam('%s.orientation' % self.handle, [0,0,90]) 
    236          
     236 
    237237        ana_val = self.ana.runXY([0.05, 0.15]) 
    238238        sim_val = self.canvas.getIq2D(0.05, 0.15) 
    239239        #print ana_val, sim_val, sim_val/ana_val 
    240          
     240 
    241241        try: 
    242242            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    243         except: 
     243        except Exception: 
    244244            print("Error", ana_val, sim_val, sim_val/ana_val) 
    245             raise sys.exc_type, sys.exc_value 
     245            raise 
    246246 
    247247class TestCoreShell(unittest.TestCase): 
    248248    """ Tests for oriented (2D) systems """ 
    249          
     249 
    250250    def setUp(self): 
    251251        """ Set up zero-SLD-average core-shell model """ 
    252         from sas.models.CoreShellModel import CoreShellModel 
    253          
     252 
    254253        radius = 15 
    255254        thickness = 5 
    256255        density = 20 
    257          
     256 
    258257        core_vol = 4.0/3.0*math.pi*radius*radius*radius 
    259258        self.outer_radius = radius+thickness 
     
    262261 
    263262        self.density = density 
    264             
     263 
    265264        # Core-shell 
    266265        sphere = CoreShellModel() 
     266        sphere.setParam('scale', 1.0) 
     267        sphere.setParam('background', 0.0) 
    267268        # Core radius 
    268269        sphere.setParam('radius', radius) 
    269270        # Shell thickness 
    270271        sphere.setParam('thickness', thickness) 
    271         sphere.setParam('core_sld', 1.0) 
    272         sphere.setParam('shell_sld', self.shell_sld) 
    273         sphere.setParam('solvent_sld', 0.0) 
    274         sphere.setParam('background', 0.0) 
    275         sphere.setParam('scale', 1.0) 
     272        sphere.setParam('sld_core', 1.0) 
     273        sphere.setParam('sld_shell', self.shell_sld) 
     274        sphere.setParam('sld_solvent', 0.0) 
    276275        self.ana = sphere 
    277         
    278         canvas = VolumeCanvas.VolumeCanvas()         
     276 
     277        canvas = VolumeCanvas.VolumeCanvas() 
    279278        canvas.setParam('lores_density', self.density) 
    280          
     279        canvas.setParam('scale' , 1.0) 
     280        canvas.setParam('background' , 0.0) 
     281 
    281282        handle = canvas.add('sphere') 
    282283        canvas.setParam('%s.radius' % handle, self.outer_radius) 
    283284        canvas.setParam('%s.contrast' % handle, self.shell_sld) 
    284         
     285 
    285286        handle2 = canvas.add('sphere') 
    286287        canvas.setParam('%s.radius' % handle2, radius) 
    287288        canvas.setParam('%s.contrast' % handle2, 1.0) 
    288                 
    289         canvas.setParam('scale' , 1.0) 
    290         canvas.setParam('background' , 0.0) 
    291         self.canvas = canvas  
    292             
     289 
     290        self.canvas = canvas 
     291 
    293292    def testdefault(self): 
    294293        """ Testing default core-shell orientation """ 
    295294        ana_val = self.ana.runXY([0.1, 0.2]) 
    296295        sim_val, err = self.canvas.getIq2DError(0.1, 0.2) 
    297          
    298         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    299                     
     296 
     297        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     298 
    300299class TestCoreShellError(unittest.TestCase): 
    301300    """ Tests for oriented (2D) systems """ 
    302          
     301 
    303302    def setUp(self): 
    304303        """ Set up zero-SLD-average core-shell model """ 
    305         from sas.models.CoreShellModel import CoreShellModel 
    306          
     304 
    307305        radius = 15 
    308306        thickness = 5 
    309307        density = 5 
    310          
     308 
    311309        core_vol = 4.0/3.0*math.pi*radius*radius*radius 
    312310        self.outer_radius = radius+thickness 
     
    315313 
    316314        self.density = density 
    317             
     315 
    318316        # Core-shell 
    319317        sphere = CoreShellModel() 
     318        sphere.setParam('scale', 1.0) 
     319        sphere.setParam('background', 0.0) 
    320320        # Core radius 
    321321        sphere.setParam('radius', radius) 
    322322        # Shell thickness 
    323323        sphere.setParam('thickness', thickness) 
    324         sphere.setParam('core_sld', 1.0) 
    325         sphere.setParam('shell_sld', self.shell_sld) 
    326         sphere.setParam('solvent_sld', 0.0) 
    327         sphere.setParam('background', 0.0) 
    328         sphere.setParam('scale', 1.0) 
     324        sphere.setParam('sld_core', 1.0) 
     325        sphere.setParam('sld_shell', self.shell_sld) 
     326        sphere.setParam('sld_solvent', 0.0) 
    329327        self.ana = sphere 
    330         
    331         canvas = VolumeCanvas.VolumeCanvas()         
     328 
     329        canvas = VolumeCanvas.VolumeCanvas() 
    332330        canvas.setParam('lores_density', self.density) 
    333          
     331        canvas.setParam('scale' , 1.0) 
     332        canvas.setParam('background' , 0.0) 
     333 
    334334        handle = canvas.add('sphere') 
    335335        canvas.setParam('%s.radius' % handle, self.outer_radius) 
    336336        canvas.setParam('%s.contrast' % handle, self.shell_sld) 
    337         
     337 
    338338        handle2 = canvas.add('sphere') 
    339339        canvas.setParam('%s.radius' % handle2, radius) 
    340340        canvas.setParam('%s.contrast' % handle2, 1.0) 
    341                 
    342         canvas.setParam('scale' , 1.0) 
    343         canvas.setParam('background' , 0.0) 
    344         self.canvas = canvas  
    345                     
     341 
     342        self.canvas = canvas 
     343 
    346344    def testdefault(self): 
    347345        """ Testing default core-shell orientation """ 
    348346        ana_val = self.ana.runXY([0.1, 0.2]) 
    349347        sim_val, err = self.canvas.getIq2DError(0.1, 0.2) 
    350          
     348 
    351349        self.assert_( math.fabs(sim_val-ana_val) < 3.0 * err ) 
    352350 
     
    356354    def setUp(self): 
    357355        """ Set up ellipsoid """ 
    358         from sas.models.EllipsoidModel import EllipsoidModel 
    359          
     356 
    360357        radius_a = 10 
    361358        radius_b = 15 
    362359        density = 5 
    363          
     360 
    364361        self.ana = EllipsoidModel() 
    365362        self.ana.setParam('scale', 1.0) 
    366         self.ana.setParam('contrast', 1.0) 
    367363        self.ana.setParam('background', 0.0) 
    368         self.ana.setParam('radius_a', radius_a) 
    369         self.ana.setParam('radius_b', radius_b) 
    370  
    371         
     364        self.ana.setParam('sld', 1.0) 
     365        self.ana.setParam('sld_solvent', 1.0) 
     366        self.ana.setParam('radius_polar', radius_a) 
     367        self.ana.setParam('radius_equatorial', radius_b) 
     368 
     369 
    372370        canvas = VolumeCanvas.VolumeCanvas() 
     371        self.handle = canvas.add('ellipsoid') 
    373372        canvas.setParam('lores_density', density) 
    374         self.handle = canvas.add('ellipsoid') 
     373        canvas.setParam('scale' , 1.0) 
     374        canvas.setParam('background' , 0.0) 
    375375        canvas.setParam('%s.radius_x' % self.handle, radius_a) 
    376376        canvas.setParam('%s.radius_y' % self.handle, radius_b) 
    377377        canvas.setParam('%s.radius_z' % self.handle, radius_b) 
    378         canvas.setParam('scale' , 1.0) 
    379378        canvas.setParam('%s.contrast' % self.handle, 1.0) 
    380         canvas.setParam('background' , 0.0) 
    381         self.canvas = canvas      
    382             
    383         self.ana.setParam('axis_theta', 1.57) 
    384         self.ana.setParam('axis_phi', 0) 
    385          
     379        self.canvas = canvas 
     380 
     381        self.ana.setParam('theta', 1.57) 
     382        self.ana.setParam('phi', 0) 
     383 
    386384        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0]) 
    387          
     385 
    388386 
    389387    def testRunXY_List(self): 
     
    392390        sim_val = self.canvas.runXY([0.1, 0.2]) 
    393391        #print ana_val, sim_val, sim_val/ana_val 
    394          
     392 
    395393        try: 
    396394            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    397         except: 
     395        except Exception: 
    398396            print("Error", ana_val, sim_val, sim_val/ana_val) 
    399             raise sys.exc_type, sys.exc_value 
     397            raise 
    400398 
    401399    def testRunXY_float(self): 
     
    404402        sim_val = self.canvas.runXY(0.1) 
    405403        #print ana_val, sim_val, sim_val/ana_val 
    406          
     404 
    407405        try: 
    408406            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    409         except: 
     407        except Exception: 
    410408            print("Error", ana_val, sim_val, sim_val/ana_val) 
    411             raise sys.exc_type, sys.exc_value 
     409            raise 
    412410 
    413411    def testRun_float(self): 
     
    416414        sim_val = self.canvas.run(0.1) 
    417415        #print ana_val, sim_val, sim_val/ana_val 
    418          
     416 
    419417        try: 
    420418            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    421         except: 
     419        except Exception: 
    422420            print("Error", ana_val, sim_val, sim_val/ana_val) 
    423             raise sys.exc_type, sys.exc_value 
     421            raise 
    424422 
    425423    def testRun_list(self): 
     
    428426        sim_val = self.canvas.run([0.1, 33.0]) 
    429427        #print ana_val, sim_val, sim_val/ana_val 
    430          
     428 
    431429        try: 
    432430            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    433         except: 
     431        except Exception: 
    434432            print("Error", ana_val, sim_val, sim_val/ana_val) 
    435             raise sys.exc_type, sys.exc_value 
     433            raise 
    436434 
    437435class TestParamChange(unittest.TestCase): 
    438436    """ Tests for oriented (2D) systems """ 
    439          
     437 
    440438    def setUp(self): 
    441439        """ Set up cylinder model """ 
    442         from sas.models.CylinderModel import CylinderModel 
    443440        radius = 5 
    444441        length = 40 
    445442        density = 20 
    446      
     443 
    447444        # Analytical model 
    448445        self.ana = CylinderModel() 
    449446        self.ana.setParam('scale', 1.0) 
    450         self.ana.setParam('contrast', 1.0) 
    451447        self.ana.setParam('background', 0.0) 
     448        self.ana.setParam('sld', 1.0) 
     449        self.ana.setParam('sld_solvent', 0.0) 
    452450        self.ana.setParam('radius', radius) 
    453451        self.ana.setParam('length', length) 
    454         self.ana.setParam('cyl_theta', math.pi/2.0) 
    455         self.ana.setParam('cyl_phi', math.pi/2.0) 
    456      
     452        self.ana.setParam('theta', math.pi/2.0) 
     453        self.ana.setParam('phi', math.pi/2.0) 
     454 
    457455        # Simulation model 
    458456        self.model = VolumeCanvas.VolumeCanvas() 
    459457        self.handle = self.model.add('cylinder') 
    460458        self.model.setParam('lores_density', density) 
     459        self.model.setParam('scale' , 1.0) 
     460        self.model.setParam('background' , 0.0) 
    461461        self.model.setParam('%s.radius' % self.handle, radius) 
    462462        self.model.setParam('%s.length' % self.handle, length) 
    463         self.model.setParam('scale' , 1.0) 
    464463        self.model.setParam('%s.contrast' % self.handle, 1.0) 
    465         self.model.setParam('background' , 0.0) 
    466464        self.model.setParam('%s.orientation' % self.handle, [0,0,0]) 
    467      
     465 
    468466    def testalongY(self): 
    469467        """ Test that a parameter change forces the generation 
     
    472470        ana_val = self.ana.runXY([0.1, 0.2]) 
    473471        sim_val = self.model.getIq2D(0.1, 0.2) 
    474          
    475         self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
    476          
     472 
     473        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 ) 
     474 
    477475        # Change the radius a re-evaluate 
    478476        self.ana.setParam('radius', 10) 
    479477        self.model.setParam('%s.radius' % self.handle, 10) 
    480          
     478 
    481479        ana_val = self.ana.runXY([0.1, 0.2]) 
    482480        sim_val = self.model.getIq2D(0.1, 0.2) 
     
    485483 
    486484if __name__ == '__main__': 
    487     unittest.main()         
     485    unittest.main() 
  • test/sasrealspace/test/utest_realspace.py

    raaf5e49 r1cdbcd8  
    99# Disable "missing docstring" complaint 
    1010# pylint: disable-msg=C0111 
    11 # Disable "too many methods" complaint  
    12 # pylint: disable-msg=R0904  
    13 # Disable "could be a function" complaint  
     11# Disable "too many methods" complaint 
     12# pylint: disable-msg=R0904 
     13# Disable "could be a function" complaint 
    1414# pylint: disable-msg=R0201 
    1515 
    16 try: 
    17     import VolumeCanvas 
    18     print("Testing local version") 
    19 except: 
    20     import sys 
    21     print(sys.exc_value) 
    22     #testing the version that is working on 
    23     print("Testing installed version") 
    24     import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
    25       
     16from sasmodels.sasview_model import _make_standard_model 
     17EllipsoidModel = _make_standard_model('ellipsoid') 
     18SphereModel = _make_standard_model('sphere') 
     19CylinderModel = _make_standard_model('cylinder') 
     20CoreShellModel = _make_standard_model('core_shell_sphere') 
     21 
     22import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas 
     23 
    2624class TestRealSpaceModel(unittest.TestCase): 
    2725    """ Unit tests for sphere model """ 
    28      
     26 
    2927    def setUp(self): 
    3028        self.model = VolumeCanvas.VolumeCanvas() 
     
    3331        self.model.add('ellipsoid', 'elli') 
    3432        self.model.add('singlehelix', 'shelix') 
    35          
     33 
    3634    def testAdding(self): 
    37         self.assertEqual('cyl', self.model.add('cylinder', 'cyl'))    
     35        self.assertEqual('cyl', self.model.add('cylinder', 'cyl')) 
    3836 
    3937    def testDeleting(self): 
     
    5553        #print "pr is calculated", self.model.hasPr 
    5654        result = self.model.getIq(0.1) 
    57         #print "I(0.1) is calculated: ", result        
     55        #print "I(0.1) is calculated: ", result 
    5856 
    5957class TestSphere(unittest.TestCase): 
     
    6260    def setUp(self): 
    6361        self.canvas = VolumeCanvas.VolumeCanvas() 
    64          
    65          
     62 
     63 
    6664    def testSetQmax(self): 
    6765        old_value = self.canvas.getParam('q_max') 
    6866        new_value = old_value + 0.1 
    6967        self.canvas.setParam('q_max', new_value) 
    70         self.assertEqual(self.canvas.getParam("Q_MAx"), new_value)          
    71          
    72     def testSetDensity(self):         
     68        self.assertEqual(self.canvas.getParam("Q_MAx"), new_value) 
     69 
     70    def testSetDensity(self): 
    7371        self.canvas.setParam('lores_density', 0.1) 
    7472        handle = self.canvas.add('sphere') 
     
    7775        npts_1 = vol/0.1 
    7876        value_1 = self.canvas.getIq(0.001) 
    79          
     77 
    8078        # Change density, the answer should be the same 
    8179        self.canvas.setParam('lores_density', 0.2) 
    8280        npts_2 = vol/0.2 
    8381        value_2 = self.canvas.getIq(0.001) 
    84          
    85         self.assert_( (value_1-value_2)/value_1 < 0.1)          
    86          
    87     def testSetDensityTiming(self):       
     82 
     83        self.assert_( (value_1-value_2)/value_1 < 0.1) 
     84 
     85    def testSetDensityTiming(self): 
    8886        """Testing change in computation time with density""" 
    8987        handle = self.canvas.add('sphere') 
    9088        self.canvas.setParam("%s.radius" % handle, 15.0) 
    91          
     89 
    9290        self.canvas.setParam('lores_density', 0.6) 
    9391        t_0 = time.time() 
    9492        self.canvas.getIq(0.001) 
    9593        t_1 = time.time()-t_0 
    96          
     94 
    9795        # Change density, the answer should be the same 
    9896        self.canvas.setParam('lores_density', 0.1) 
     
    10098        self.canvas.getIq(0.001) 
    10199        t_2 = time.time()-t_0 
    102          
    103         self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2)          
    104          
     100 
     101        self.assert_( t_2 < t_1 and (t_1-t_2)/t_2 > 2) 
     102 
    105103    def testGetParamList(self): 
    106104        """ Test GetParamList on empty canvas""" 
    107105        self.assert_('lores_density' in self.canvas.getParamList()) 
    108106        handle = self.canvas.add('sphere') 
    109          
     107 
    110108    def testGetParamListWithShape(self): 
    111109        """ Test GetParamList on filled canvas""" 
    112110        self.canvas.add('sphere') 
    113111        self.assert_('lores_density' in self.canvas.getParamList()) 
    114          
     112 
    115113    def testAdd(self): 
    116114        handle = "s1" 
    117115        self.assertEqual(handle, self.canvas.add('sphere', handle)) 
    118   
     116 
    119117        #TODO: test for current list of shape 
    120118        self.assertEqual( [handle] , self.canvas.getShapeList()) 
    121          
     119 
    122120    def testSetRadius(self): 
    123121        handle = self.canvas.add('sphere') 
    124         self.canvas.setParam("%s.rAdius" % handle, 24.0) 
    125         self.assertEqual(self.canvas.getParam("%s.rAdius" % handle), 24.0) 
     122        self.canvas.setParam("%s.radius" % handle, 24.0) 
     123        self.assertEqual(self.canvas.getParam("%s.radius" % handle), 24.0) 
    126124 
    127125    def testGetIq(self): 
    128126        """ Test the output of I(q) to the analytical solution 
    129127            If the normalization is wrong, we will have to fix it. 
    130              
     128 
    131129            getIq() should call getPr() behind the scenes so that 
    132130            the user doesnt have to do it if he doesn't need to. 
    133131        """ 
    134         from sas.models.SphereModel import SphereModel 
    135132        sphere = SphereModel() 
     133        sphere.setParam('scale', 1.0) 
     134        sphere.setParam('background', 0.0) 
     135        sphere.setParam('sld', 1.0) 
     136        sphere.setParam('sld_solvent', 0.0) 
    136137        sphere.setParam('radius', 10.0) 
    137         sphere.setParam('contrast', 1.0) 
    138         sphere.setParam('background', 0.0) 
    139         sphere.setParam('scale', 1.0) 
    140                  
     138 
    141139        handle = self.canvas.add('sphere') 
    142140        self.canvas.setParam('%s.radius' % handle, 10.0) 
    143141        self.canvas.setParam('%s.contrast' % handle, 1.0) 
    144          
    145          
     142 
     143 
    146144        sim_1 = self.canvas.getIq(0.001) 
    147145        ana_1 = sphere.run(0.001) 
    148146        sim_2 = self.canvas.getIq(0.01) 
    149147        ana_2 = sphere.run(0.01) 
    150          
    151         # test the shape of the curve (calculate relative error  
     148 
     149        # test the shape of the curve (calculate relative error 
    152150        # on the output and it should be compatible with zero 
    153151        # THIS WILL DEPEND ON THE NUMBER OF SPACE POINTS: 
    154152        # that why we need some error analysis. 
    155153        self.assert_( (sim_2*ana_1/sim_1 - ana_2)/ana_2 < 0.1) 
    156          
     154 
    157155        # test the absolute amplitude 
    158156        self.assert_( math.fabs(sim_2-ana_2)/ana_2 < 0.1) 
    159          
     157 
    160158    def testGetIq2(self): 
    161159        """ Test two different q values 
     
    163161        handle = self.canvas.add('sphere') 
    164162        self.canvas.setParam('%s.radius' % handle, 10.0) 
    165          
     163 
    166164        sim_1 = self.canvas.getIq(0.001) 
    167165        sim_2 = self.canvas.getIq(0.01) 
    168          
     166 
    169167        self.assertNotAlmostEqual(sim_2, sim_1, 3) 
    170          
     168 
    171169    def testGetIq_Identical(self): 
    172170        """ Test for identical model / no param change 
     
    174172        handle = self.canvas.add('sphere') 
    175173        self.canvas.setParam('%s.radius' % handle, 10.0) 
    176          
     174 
    177175        sim_1 = self.canvas.getIq(0.01) 
    178176        sim_2 = self.canvas.getIq(0.01) 
    179          
     177 
    180178        self.assertEqual(sim_2, sim_1) 
    181          
     179 
    182180    def testGetIq_Identical2(self): 
    183181        """ Test for identical model after a parameter change