Changeset 5bb05a4 in sasview for src/sas/sascalc

Timestamp:

Dec 6, 2017 11:04:17 AM (7 years ago)

Author:

GitHub <noreply@…>

Branches:

master, magnetic_scatt, release-4.2.2, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

a64f8f4, b6b81a3, 0a88623, 66285f5

Parents:

f53d684 (diff), bc4f5bb (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.

git-author:

Paul Kienzle <pkienzle@…> (12/06/17 11:04:17)

git-committer:

GitHub <noreply@…> (12/06/17 11:04:17)

Message:

Merge pull request 127 from SasView?/ticket-1032-sldi. Closes #1032.

Location:

src/sas/sascalc

Files:

• calculator/c_extensions/libfunc.c (modified) (2 diffs)
• calculator/c_extensions/libfunc.h (modified) (1 diff)
• calculator/c_extensions/librefl.c (modified) (9 diffs)
• calculator/c_extensions/librefl.h (modified) (1 diff)
• calculator/c_extensions/sld2i.c (moved) (moved from src/sas/sascalc/calculator/c_extensions/sld2i.cpp) (9 diffs)
• calculator/c_extensions/sld2i.h (added)
• calculator/c_extensions/sld2i.hh (deleted)
• calculator/c_extensions/sld2i_module.c (moved) (moved from src/sas/sascalc/calculator/c_extensions/sld2i_module.cpp) (7 diffs)
• calculator/sas_gen.py (modified) (9 diffs)
• dataloader/file_reader_base_class.py (modified) (4 diffs)
• dataloader/readers/cansas_reader.py (modified) (10 diffs)
• dataloader/readers/danse_reader.py (modified) (3 diffs)
• dataloader/readers/sesans_reader.py (modified) (5 diffs)
• fit/MultiplicationModel.py (modified) (3 diffs)
• fit/qsmearing.py (modified) (2 diffs)
• pr/invertor.py (modified) (5 diffs)
• pr/num_term.py (modified) (4 diffs)

src/sas/sascalc/calculator/c_extensions/libfunc.c

@@ -95 +95 @@
 // spintheta: angle (anti-clock-wise) between neutron spin(up) and x axis
 // Note: all angles are in degrees.
-polar_sld cal_msld(int isangle, double qx, double qy, double bn,
+void cal_msld(polar_sld *p_sld, int isangle, double qx, double qy, double bn,
                                 double m01, double mtheta1, double mphi1,
                                 double spinfraci, double spinfracf, double spintheta)
@@ -124 +124 @@
         double my = 0.0;
         double mz = 0.0;
-        polar_sld p_sld;
-        p_sld.uu = sld;
-        p_sld.dd = sld;
-        p_sld.re_ud = 0.0;
-        p_sld.im_ud = 0.0;
-        p_sld.re_du = 0.0;
-        p_sld.im_du = 0.0;
+        double uu = sld;
+        double dd = sld;
+        double re_ud = 0.0;
+        double im_ud = 0.0;
+        double re_du = 0.0;
+        double im_du = 0.0;
 
         //No mag means no further calculation
-        if (isangle>0){
+        if (isangle>0) {
                 if (m_max < 1.0e-32){
-                        p_sld.uu = sqrt(sqrt(in_spin * out_spin)) * p_sld.uu;
-                        p_sld.dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * p_sld.dd;
-                        return p_sld;
-                }
-        }
-        else{
-                if (fabs(m_max)< 1.0e-32 && fabs(m_phi)< 1.0e-32 && fabs(m_theta)< 1.0e-32){
-                        p_sld.uu = sqrt(sqrt(in_spin * out_spin)) * p_sld.uu;
-                        p_sld.dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * p_sld.dd;
-                        return p_sld;
-                }
-        }
-
-        //These are needed because of the precision of inputs
-        if (in_spin < 0.0) in_spin = 0.0;
-        if (in_spin > 1.0) in_spin = 1.0;
-        if (out_spin < 0.0) out_spin = 0.0;
-        if (out_spin > 1.0) out_spin = 1.0;
-
-        if (q_x == 0.0) q_angle = pi / 2.0;
-        else q_angle = atan(q_y/q_x);
-        if (q_y < 0.0 && q_x < 0.0) q_angle -= pi;
-        else if (q_y > 0.0 && q_x < 0.0) q_angle += pi;
-
-        q_angle = pi/2.0 - q_angle;
-        if (q_angle > pi) q_angle -= 2.0 * pi;
-        else if (q_angle < -pi) q_angle += 2.0 * pi;
-
-        if (fabs(q_x) < 1.0e-16 && fabs(q_y) < 1.0e-16){
-                m_perp = 0.0;
-                }
-        else {
-                m_perp = m_max;
-                }
-        if (is_angle > 0){
-                m_phi *= pi/180.0;
-                m_theta *= pi/180.0;
-                mx = m_perp * cos(m_theta) * cos(m_phi);
-                my = m_perp * sin(m_theta);
-                mz = -(m_perp * cos(m_theta) * sin(m_phi));
-        }
-        else{
-                mx = m_perp;
-                my = m_phi;
-                mz = m_theta;
-        }
-        //ToDo: simplify these steps
-        // m_perp1 -m_perp2
-        m_perp_x = (mx) *  cos(q_angle);
-        m_perp_x -= (my) * sin(q_angle);
-        m_perp_y = m_perp_x;
-        m_perp_x *= cos(-q_angle);
-        m_perp_y *= sin(-q_angle);
-        m_perp_z = mz;
-
-        m_sigma_x = (m_perp_x * cos(-s_theta) - m_perp_y * sin(-s_theta));
-        m_sigma_y = (m_perp_x * sin(-s_theta) + m_perp_y * cos(-s_theta));
-        m_sigma_z = (m_perp_z);
-
-        //Find b
-        p_sld.uu -= m_sigma_x;
-        p_sld.dd += m_sigma_x;
-        p_sld.re_ud = m_sigma_y;
-        p_sld.re_du = m_sigma_y;
-        p_sld.im_ud = m_sigma_z;
-        p_sld.im_du = -m_sigma_z;
-
-        p_sld.uu = sqrt(sqrt(in_spin * out_spin)) * p_sld.uu;
-        p_sld.dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * p_sld.dd;
-
-        p_sld.re_ud = sqrt(sqrt(in_spin * (1.0 - out_spin))) * p_sld.re_ud;
-        p_sld.im_ud = sqrt(sqrt(in_spin * (1.0 - out_spin))) * p_sld.im_ud;
-        p_sld.re_du = sqrt(sqrt((1.0 - in_spin) * out_spin)) * p_sld.re_du;
-        p_sld.im_du = sqrt(sqrt((1.0 - in_spin) * out_spin)) * p_sld.im_du;
-
-        return p_sld;
+                        uu = sqrt(sqrt(in_spin * out_spin)) * uu;
+                        dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * dd;
+                }
+        }
+        else if (fabs(m_max)< 1.0e-32 && fabs(m_phi)< 1.0e-32 && fabs(m_theta)< 1.0e-32){
+                        uu = sqrt(sqrt(in_spin * out_spin)) * uu;
+                        dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * dd;
+        } else {
+
+                //These are needed because of the precision of inputs
+                if (in_spin < 0.0) in_spin = 0.0;
+                if (in_spin > 1.0) in_spin = 1.0;
+                if (out_spin < 0.0) out_spin = 0.0;
+                if (out_spin > 1.0) out_spin = 1.0;
+
+                if (q_x == 0.0) q_angle = pi / 2.0;
+                else q_angle = atan(q_y/q_x);
+                if (q_y < 0.0 && q_x < 0.0) q_angle -= pi;
+                else if (q_y > 0.0 && q_x < 0.0) q_angle += pi;
+
+                q_angle = pi/2.0 - q_angle;
+                if (q_angle > pi) q_angle -= 2.0 * pi;
+                else if (q_angle < -pi) q_angle += 2.0 * pi;
+
+                if (fabs(q_x) < 1.0e-16 && fabs(q_y) < 1.0e-16){
+                        m_perp = 0.0;
+                        }
+                else {
+                        m_perp = m_max;
+                        }
+                if (is_angle > 0){
+                        m_phi *= pi/180.0;
+                        m_theta *= pi/180.0;
+                        mx = m_perp * cos(m_theta) * cos(m_phi);
+                        my = m_perp * sin(m_theta);
+                        mz = -(m_perp * cos(m_theta) * sin(m_phi));
+                }
+                else{
+                        mx = m_perp;
+                        my = m_phi;
+                        mz = m_theta;
+                }
+                //ToDo: simplify these steps
+                // m_perp1 -m_perp2
+                m_perp_x = (mx) *  cos(q_angle);
+                m_perp_x -= (my) * sin(q_angle);
+                m_perp_y = m_perp_x;
+                m_perp_x *= cos(-q_angle);
+                m_perp_y *= sin(-q_angle);
+                m_perp_z = mz;
+
+                m_sigma_x = (m_perp_x * cos(-s_theta) - m_perp_y * sin(-s_theta));
+                m_sigma_y = (m_perp_x * sin(-s_theta) + m_perp_y * cos(-s_theta));
+                m_sigma_z = (m_perp_z);
+
+                //Find b
+                uu -= m_sigma_x;
+                dd += m_sigma_x;
+                re_ud = m_sigma_y;
+                re_du = m_sigma_y;
+                im_ud = m_sigma_z;
+                im_du = -m_sigma_z;
+
+                uu = sqrt(sqrt(in_spin * out_spin)) * uu;
+                dd = sqrt(sqrt((1.0 - in_spin) * (1.0 - out_spin))) * dd;
+
+                re_ud = sqrt(sqrt(in_spin * (1.0 - out_spin))) * re_ud;
+                im_ud = sqrt(sqrt(in_spin * (1.0 - out_spin))) * im_ud;
+                re_du = sqrt(sqrt((1.0 - in_spin) * out_spin)) * re_du;
+                im_du = sqrt(sqrt((1.0 - in_spin) * out_spin)) * im_du;
+        }
+        p_sld->uu = uu;
+        p_sld->dd = dd;
+        p_sld->re_ud = re_ud;
+        p_sld->im_ud = im_ud;
+        p_sld->re_du = re_du;
+        p_sld->im_du = im_du;
 }
 

src/sas/sascalc/calculator/c_extensions/libfunc.h

@@ -18 +18 @@
 //double gamln(double x);
 
-polar_sld cal_msld(int isangle, double qx, double qy, double bn, double m01, double mtheta1, 
+void cal_msld(polar_sld*, int isangle, double qx, double qy, double bn, double m01, double mtheta1, 
                         double mphi1, double spinfraci, double spinfracf, double spintheta);
 

src/sas/sascalc/calculator/c_extensions/librefl.c

@@ -7 +7 @@
 #include <stdio.h>
 #include <stdlib.h>
-#if defined(_MSC_VER)
+#if defined _MSC_VER  || defined __TINYCC__
 #define NEED_ERF
 #endif
@@ -21 +21 @@
 
 
-#ifdef _WIN32
+#ifdef __TINYCC__
+# ifdef isnan
+#   undef isnan
+# endif
+# ifdef isfinite
+#   undef isfinite
+# endif
+# define isnan(x) (x != x)
+# define isfinite(x) (x != INFINITY && x != -INFINITY)
+#elif defined _WIN32
 # include <float.h>
 # if !defined __MINGW32__ || defined __NO_ISOCEXT
@@ -30 +39 @@
 #   define isinf(x) (!_finite(x) && !_isnan(x))
 #  endif
-#  ifndef finite
-#   define finite(x) _finite(x)
+#  ifndef isfinite
+#   define isfinite(x) _finite(x)
 #  endif
 # endif
@@ -84 +93 @@
 double erf(double x)
 {
-    if (!finite(x)) {
+    if (!isfinite(x)) {
         if (isnan(x)) return x;      /* erf(NaN)   = NaN   */
         return (x>0 ? 1.0 : -1.0);   /* erf(+-inf) = +-1.0 */
@@ -94 +103 @@
 double erfc(double x)
 {
-    if (!finite(x)) {
+    if (!isfinite(x)) {
         if (isnan(x)) return x;      /* erfc(NaN)   = NaN      */
         return (x>0 ? 0.0 : 2.0);    /* erfc(+-inf) = 0.0, 2.0 */
@@ -103 +112 @@
 #endif // NEED_ERF
 
-complex cassign(real, imag)
-        double real, imag;
-{
-        complex x;
-        x.re = real;
-        x.im = imag;
-        return x;
-}
-
-
-complex cplx_add(x,y)
-        complex x,y;
-{
-        complex z;
-        z.re = x.re + y.re;
-        z.im = x.im + y.im;
-        return z;
-}
-
-complex rcmult(x,y)
-        double x;
-    complex y;
-{
-        complex z;
-        z.re = x*y.re;
-        z.im = x*y.im;
-        return z;
-}
-
-complex cplx_sub(x,y)
-        complex x,y;
-{
-        complex z;
-        z.re = x.re - y.re;
-        z.im = x.im - y.im;
-        return z;
-}
-
-
-complex cplx_mult(x,y)
-        complex x,y;
-{
-        complex z;
-        z.re = x.re*y.re - x.im*y.im;
-        z.im = x.re*y.im + x.im*y.re;
-        return z;
-}
-
-complex cplx_div(x,y)
-        complex x,y;
-{
-        complex z;
-        z.re = (x.re*y.re + x.im*y.im)/(y.re*y.re + y.im*y.im);
-        z.im = (x.im*y.re - x.re*y.im)/(y.re*y.re + y.im*y.im);
-        return z;
-}
-
-complex cplx_exp(b)
-        complex b;
-{
-        complex z;
+void cassign(Cplx *x, double real, double imag)
+{
+        x->re = real;
+        x->im = imag;
+}
+
+
+void cplx_add(Cplx *z, Cplx x, Cplx y)
+{
+        z->re = x.re + y.re;
+        z->im = x.im + y.im;
+}
+
+void rcmult(Cplx *z, double x, Cplx y)
+{
+        z->re = x*y.re;
+        z->im = x*y.im;
+}
+
+void cplx_sub(Cplx *z, Cplx x, Cplx y)
+{
+        z->re = x.re - y.re;
+        z->im = x.im - y.im;
+}
+
+
+void cplx_mult(Cplx *z, Cplx x, Cplx y)
+{
+        z->re = x.re*y.re - x.im*y.im;
+        z->im = x.re*y.im + x.im*y.re;
+}
+
+void cplx_div(Cplx *z, Cplx x, Cplx y)
+{
+        z->re = (x.re*y.re + x.im*y.im)/(y.re*y.re + y.im*y.im);
+        z->im = (x.im*y.re - x.re*y.im)/(y.re*y.re + y.im*y.im);
+}
+
+void cplx_exp(Cplx *z, Cplx b)
+{
         double br,bi;
         br=b.re;
         bi=b.im;
-        z.re = exp(br)*cos(bi);
-        z.im = exp(br)*sin(bi);
-        return z;
-}
-
-
-complex cplx_sqrt(z)    //see Schaum`s Math Handbook p. 22, 6.6 and 6.10
-        complex z;
-{
-        complex c;
+        z->re = exp(br)*cos(bi);
+        z->im = exp(br)*sin(bi);
+}
+
+
+void cplx_sqrt(Cplx *c, Cplx z)    //see Schaum`s Math Handbook p. 22, 6.6 and 6.10
+{
         double zr,zi,x,y,r,w;
 
@@ -184 +169 @@
         if (zr==0.0 && zi==0.0)
         {
-    c.re=0.0;
-        c.im=0.0;
-    return c;
-        }
-        else
-        {
+                c->re=0.0;
+                c->im=0.0;
+        } else {
                 x=fabs(zr);
                 y=fabs(zi);
@@ -196 +178 @@
                         r=y/x;
                         w=sqrt(x)*sqrt(0.5*(1.0+sqrt(1.0+r*r)));
-                }
-                else
-                {
+                } else {
                         r=x/y;
                         w=sqrt(y)*sqrt(0.5*(r+sqrt(1.0+r*r)));
@@ -204 +184 @@
                 if (zr >=0.0)
                 {
-                        c.re=w;
-                        c.im=zi/(2.0*w);
+                        c->re=w;
+                        c->im=zi/(2.0*w);
+                } else {
+                        c->im=(zi >= 0) ? w : -w;
+                        c->re=zi/(2.0*c->im);
                 }
-                else
-                {
-                        c.im=(zi >= 0) ? w : -w;
-                        c.re=zi/(2.0*c.im);
-                }
-                return c;
-        }
-}
-
-complex cplx_cos(b)
-        complex b;
-{
-        complex zero,two,z,i,bi,negbi;
-        zero = cassign(0.0,0.0);
-        two = cassign(2.0,0.0);
-        i = cassign(0.0,1.0);
-        bi = cplx_mult(b,i);
-        negbi = cplx_sub(zero,bi);
-        z = cplx_div(cplx_add(cplx_exp(bi),cplx_exp(negbi)),two);
-        return z;
+        }
+}
+
+void cplx_cos(Cplx *z, Cplx b)
+{
+        // cos(b) = (e^bi + e^-bi)/2
+        //        = (e^b.im e^-i bi.re) + e^-b.im e^i b.re)/2
+        //        = (e^b.im cos(-b.re) + e^b.im sin(-b.re) i)/2 + (e^-b.im cos(b.re) + e^-b.im sin(b.re) i)/2
+        //        = e^b.im cos(b.re)/2 - e^b.im sin(b.re)/2 i + 1/e^b.im cos(b.re)/2 + 1/e^b.im sin(b.re)/2 i
+        //        = (e^b.im + 1/e^b.im)/2 cos(b.re) + (-e^b.im + 1/e^b.im)/2 sin(b.re) i
+        //        = cosh(b.im) cos(b.re) - sinh(b.im) sin(b.re) i
+        double exp_b_im = exp(b.im);
+        z->re = 0.5*(+exp_b_im + 1.0/exp_b_im) * cos(b.re);
+        z->im = -0.5*(exp_b_im - 1.0/exp_b_im) * sin(b.re);
 }
 

src/sas/sascalc/calculator/c_extensions/librefl.h

@@ -5 +5 @@
         double re;
         double im;
-} complex;
+} Cplx;
 
 typedef struct {
-        complex a;
-        complex b;
-        complex c;
-        complex d;
+        Cplx a;
+        Cplx b;
+        Cplx c;
+        Cplx d;
 } matrix;
 
-complex cassign(double real, double imag);
+void cassign(Cplx*, double real, double imag);
 
-complex cplx_add(complex x,complex y);
+void cplx_add(Cplx*, Cplx x,Cplx y);
 
-complex rcmult(double x,complex y);
+void rcmult(Cplx*, double x,Cplx y);
 
-complex cplx_sub(complex x,complex y);
+void cplx_sub(Cplx*, Cplx x,Cplx y);
 
-complex cplx_mult(complex x,complex y);
+void cplx_mult(Cplx*, Cplx x,Cplx y);
 
-complex cplx_div(complex x,complex y);
+void cplx_div(Cplx*, Cplx x,Cplx y);
 
-complex cplx_exp(complex b);
+void cplx_exp(Cplx*, Cplx b);
 
-complex cplx_sqrt(complex z);
+void cplx_sqrt(Cplx*, Cplx z);
 
-complex cplx_cos(complex b);
+void cplx_cos(Cplx*, Cplx b);
 
 double intersldfunc(int fun_type, double n_sub, double i, double nu, double sld_l, double sld_r);

src/sas/sascalc/calculator/c_extensions/sld2i.c

@@ -2 +2 @@
 Computes the (magnetic) scattering form sld (n and m) profile
  */
-#include "sld2i.hh"
 #include <stdio.h>
 #include <math.h>
-using namespace std;
-extern "C" {
-        #include "libfunc.h"
-        #include "librefl.h"
-}
+#include "sld2i.h"
+#include "libfunc.h"
+#include "librefl.h"
 /**
  * Constructor for GenI
@@ -28 +25 @@
  * @param s_theta: angle (from x-axis) of the up spin in degree
  */
-GenI :: GenI(int npix, double* x, double* y, double* z, double* sldn,
+void initGenI(GenI* this, int is_avg, int npix, double* x, double* y, double* z, double* sldn,
                         double* mx, double* my, double* mz, double* voli,
                         double in_spin, double out_spin,
                         double s_theta) {
-        //this->qx_val = qx;
-        //this->qy_val = qy;
-        //this->qz_val = qz;
+        this->is_avg = is_avg;
         this->n_pix = npix;
         this->x_val = x;
@@ -47 +42 @@
         this->outspin = out_spin;
         this->stheta = s_theta;
-};
+}
 
 /**
  * Compute 2D anisotropic
  */
-void GenI :: genicomXY(int npoints, double *qx, double *qy, double *I_out){
-        //npoints is given negative for angular averaging 
+void genicomXY(GenI* this, int npoints, double *qx, double *qy, double *I_out){
+        //npoints is given negative for angular averaging
         // Assumes that q doesn't have qz component and sld_n is all real
         //double q = 0.0;
@@ -59 +54 @@
         polar_sld b_sld;
         double qr = 0.0;
-        complex iqr = cassign(0.0, 0.0);
-        complex ephase = cassign(0.0, 0.0);
-        complex comp_sld = cassign(0.0, 0.0);
-
-        complex sumj_uu;
-        complex sumj_ud;
-        complex sumj_du;
-        complex sumj_dd;
-        complex temp_fi;
+        Cplx iqr;
+        Cplx ephase;
+        Cplx comp_sld;
+
+        Cplx sumj_uu;
+        Cplx sumj_ud;
+        Cplx sumj_du;
+        Cplx sumj_dd;
+        Cplx temp_fi;
 
         double count = 0.0;
-        //check if this computation is for averaging
+        int i, j;
+
+        cassign(&iqr, 0.0, 0.0);
+        cassign(&ephase, 0.0, 0.0);
+        cassign(&comp_sld, 0.0, 0.0);
 
         //Assume that pixel volumes are given in vol_pix in A^3 unit
@@ -76 +75 @@
         //int y_size = 0; //in Ang
         //int z_size = 0; //in Ang
-        
+
         // Loop over q-values and multiply apply matrix
-        
-        for(int i=0; i<npoints; i++){
+
+        //printf("npoints: %d, npix: %d\n", npoints, this->n_pix);
+        for(i=0; i<npoints; i++){
                 //I_out[i] = 0.0;
-                sumj_uu = cassign(0.0, 0.0);
-                sumj_ud = cassign(0.0, 0.0);
-                sumj_du = cassign(0.0, 0.0);
-                sumj_dd = cassign(0.0, 0.0);            
-                //printf ("%d ", i);
+                cassign(&sumj_uu, 0.0, 0.0);
+                cassign(&sumj_ud, 0.0, 0.0);
+                cassign(&sumj_du, 0.0, 0.0);
+                cassign(&sumj_dd, 0.0, 0.0);
+                //printf("i: %d\n", i);
                 //q = sqrt(qx[i]*qx[i] + qy[i]*qy[i]); // + qz[i]*qz[i]);
 
-                for(int j=0; j<n_pix; j++){
-                        if (sldn_val[j]!=0.0||mx_val[j]!=0.0||my_val[j]!=0.0||mz_val[j]!=0.0)
-                        {       
+                for(j=0; j<this->n_pix; j++){
+                        if (this->sldn_val[j]!=0.0
+                                ||this->mx_val[j]!=0.0
+                                ||this->my_val[j]!=0.0
+                                ||this->mz_val[j]!=0.0)
+                        {
+                            // printf("i,j: %d,%d\n", i,j);
                                 //anisotropic
-                                temp_fi = cassign(0.0, 0.0);
-                                b_sld = cal_msld(0, qx[i], qy[i], sldn_val[j],
-                                                         mx_val[j], my_val[j], mz_val[j],
-                                                         inspin, outspin, stheta);
-                                qr = (qx[i]*x_val[j] + qy[i]*y_val[j]);
-                                iqr = cassign(0.0, qr);
-                                ephase = cplx_exp(iqr);
-                                
+                                cassign(&temp_fi, 0.0, 0.0);
+                                cal_msld(&b_sld, 0, qx[i], qy[i], this->sldn_val[j],
+                                                         this->mx_val[j], this->my_val[j], this->mz_val[j],
+                                                         this->inspin, this->outspin, this->stheta);
+                                qr = (qx[i]*this->x_val[j] + qy[i]*this->y_val[j]);
+                                cassign(&iqr, 0.0, qr);
+                                cplx_exp(&ephase, iqr);
+
                                 //Let's multiply pixel(atomic) volume here
-                                ephase = rcmult(vol_pix[j], ephase);
+                                rcmult(&ephase, this->vol_pix[j], ephase);
                                 //up_up
-                                if (inspin > 0.0 && outspin > 0.0){
-                                        comp_sld = cassign(b_sld.uu, 0.0);
-                                        temp_fi = cplx_mult(comp_sld, ephase);
-                                        sumj_uu = cplx_add(sumj_uu, temp_fi);
+                                if (this->inspin > 0.0 && this->outspin > 0.0){
+                                        cassign(&comp_sld, b_sld.uu, 0.0);
+                                        cplx_mult(&temp_fi, comp_sld, ephase);
+                                        cplx_add(&sumj_uu, sumj_uu, temp_fi);
                                 }
                                 //down_down
-                                if (inspin < 1.0 && outspin < 1.0){
-                                        comp_sld = cassign(b_sld.dd, 0.0);
-                                        temp_fi = cplx_mult(comp_sld, ephase);
-                                        sumj_dd = cplx_add(sumj_dd, temp_fi);
+                                if (this->inspin < 1.0 && this->outspin < 1.0){
+                                        cassign(&comp_sld, b_sld.dd, 0.0);
+                                        cplx_mult(&temp_fi, comp_sld, ephase);
+                                        cplx_add(&sumj_dd, sumj_dd, temp_fi);
                                 }
                                 //up_down
-                                if (inspin > 0.0 && outspin < 1.0){
-                                        comp_sld = cassign(b_sld.re_ud, b_sld.im_ud);
-                                        temp_fi = cplx_mult(comp_sld, ephase);
-                                        sumj_ud = cplx_add(sumj_ud, temp_fi);
+                                if (this->inspin > 0.0 && this->outspin < 1.0){
+                                        cassign(&comp_sld, b_sld.re_ud, b_sld.im_ud);
+                                        cplx_mult(&temp_fi, comp_sld, ephase);
+                                        cplx_add(&sumj_ud, sumj_ud, temp_fi);
                                 }
                                 //down_up
-                                if (inspin < 1.0 && outspin > 0.0){
-                                        comp_sld = cassign(b_sld.re_du, b_sld.im_du);
-                                        temp_fi = cplx_mult(comp_sld, ephase);
-                                        sumj_du = cplx_add(sumj_du, temp_fi);
-                                }
-
+                                if (this->inspin < 1.0 && this->outspin > 0.0){
+                                        cassign(&comp_sld, b_sld.re_du, b_sld.im_du);
+                                        cplx_mult(&temp_fi, comp_sld, ephase);
+                                        cplx_add(&sumj_du, sumj_du, temp_fi);
+                                }
 
                                 if (i == 0){
-                                        count += vol_pix[j];
+                                        count += this->vol_pix[j];
                                 }
                         }
@@ -142 +145 @@
                 I_out[i] *= (1.0E+8 / count); //in cm (unit) / number; //to be multiplied by vol_pix
         }
-        //printf ("count = %d %g %g %g %g\n", count, sldn_val[0],mx_val[0], my_val[0], mz_val[0]);
+        //printf("count = %d %g %g %g %g\n", count, this->sldn_val[0],this->mx_val[0], this->my_val[0], this->mz_val[0]);
 }
 /**
@@ -149 +152 @@
  * Also assumes there is no polarization: No dependency on spin
  */
-void GenI :: genicom(int npoints, double *q, double *I_out){
-        //npoints is given negative for angular averaging 
+void genicom(GenI* this, int npoints, double *q, double *I_out){
+        //npoints is given negative for angular averaging
         // Assumes that q doesn't have qz component and sld_n is all real
         //double Pi = 4.0*atan(1.0);
-        int is_sym = 0;
         double qr = 0.0;
         double sumj;
         double sld_j = 0.0;
         double count = 0.0;
-        if (n_pix < 0 ){
-                is_sym = 1;
-                n_pix = n_pix * -1;
-        }
+        int i, j, k;
+
         //Assume that pixel volumes are given in vol_pix in A^3 unit
         // Loop over q-values and multiply apply matrix
-        for(int i=0; i<npoints; i++){
-                sumj =0.0;              
-                for(int j=0; j<n_pix; j++){
+        for(i=0; i<npoints; i++){
+                sumj =0.0;
+                for(j=0; j<this->n_pix; j++){
                         //Isotropic: Assumes all slds are real (no magnetic)
                         //Also assumes there is no polarization: No dependency on spin
-                        if (is_sym == 1){
+                        if (this->is_avg == 1){
                                 // approximation for a spherical symmetric particle
-                                qr = sqrt(x_val[j]*x_val[j]+y_val[j]*y_val[j]+z_val[j]*z_val[j])*q[i];
+                                qr = sqrt(this->x_val[j]*this->x_val[j]+this->y_val[j]*this->y_val[j]+this->z_val[j]*this->z_val[j])*q[i];
                                 if (qr > 0.0){
                                         qr = sin(qr) / qr;
-                                        sumj += sldn_val[j] * vol_pix[j] * qr;
+                                        sumj += this->sldn_val[j] * this->vol_pix[j] * qr;
                                 }
                                 else{
-                                        sumj += sldn_val[j] * vol_pix[j];
+                                        sumj += this->sldn_val[j] * this->vol_pix[j];
                                 }
                         }
@@ -183 +183 @@
                                 //full calculation
                                 //pragma omp parallel for
-                                for(int k=0; k<n_pix; k++){
-                                        sld_j =  sldn_val[j] * sldn_val[k] * vol_pix[j] * vol_pix[k];
-                                        qr = (x_val[j]-x_val[k])*(x_val[j]-x_val[k])+
-                                                      (y_val[j]-y_val[k])*(y_val[j]-y_val[k])+ 
-                                                      (z_val[j]-z_val[k])*(z_val[j]-z_val[k]);
+                                for(k=0; k<this->n_pix; k++){
+                                        sld_j =  this->sldn_val[j] * this->sldn_val[k] * this->vol_pix[j] * this->vol_pix[k];
+                                        qr = (this->x_val[j]-this->x_val[k])*(this->x_val[j]-this->x_val[k])+
+                                                      (this->y_val[j]-this->y_val[k])*(this->y_val[j]-this->y_val[k])+
+                                                      (this->z_val[j]-this->z_val[k])*(this->z_val[j]-this->z_val[k]);
                                         qr = sqrt(qr) * q[i];
                                         if (qr > 0.0){
@@ -198 +198 @@
                         }
                         if (i == 0){
-                                count += vol_pix[j];
+                                count += this->vol_pix[j];
                         }
                 }
                 I_out[i] = sumj;
-                if (is_sym == 1){
+                if (this->is_avg == 1) {
                         I_out[i] *= sumj;
                 }
                 I_out[i] *= (1.0E+8 / count); //in cm (unit) / number; //to be multiplied by vol_pix
         }
-        //printf ("count = %d %g %g %g %g\n", count, sldn_val[0],mx_val[0], my_val[0], mz_val[0]);
+        //printf("count = %d %g %g %g %g\n", count, sldn_val[0],mx_val[0], my_val[0], mz_val[0]);
 }

src/sas/sascalc/calculator/c_extensions/sld2i_module.c

@@ -4 +4 @@
 #include <Python.h>
 #include <stdio.h>
-#include <sld2i.hh>
+#include "sld2i.h"
 
 #if PY_MAJOR_VERSION < 3
@@ -35 +35 @@
 void
 del_sld2i(PyObject *obj){
-        GenI* sld2i = static_cast<GenI *>(PyCapsule_GetPointer(obj, "GenI"));
-        delete sld2i;
-        return;
+#if PY_MAJOR_VERSION < 3
+        GenI* sld2i = (GenI *)obj;
+#else
+        GenI* sld2i = (GenI *)(PyCapsule_GetPointer(obj, "GenI"));
+#endif
+        PyMem_Free((void *)sld2i);
 }
 
@@ -43 +46 @@
  * Create a GenI as a python object by supplying arrays
  */
-PyObject * new_GenI(PyObject *, PyObject *args) {
+PyObject * new_GenI(PyObject *self, PyObject *args) {
         PyObject *x_val_obj;
         PyObject *y_val_obj;
@@ -52 +55 @@
         PyObject *mz_val_obj;
         PyObject *vol_pix_obj;
-        Py_ssize_t n_x;
-        //PyObject rlimit_obj;
-        //PyObject npoints_obj;
-        //PyObject nrbins_obj;
-        //PyObject nphibins_obj;
-        int n_pix;
+        Py_ssize_t n_x, n_y, n_z, n_sld, n_mx, n_my, n_mz, n_vol_pix;
+        int is_avg;
         double* x_val;
         double* y_val;
@@ -69 +68 @@
         double outspin;
         double stheta;
-
-        if (!PyArg_ParseTuple(args, "iOOOOOOOOddd", &n_pix, &x_val_obj, &y_val_obj, &z_val_obj, &sldn_val_obj, &mx_val_obj, &my_val_obj, &mz_val_obj, &vol_pix_obj, &inspin, &outspin, &stheta)) return NULL;
-        OUTVECTOR(x_val_obj, x_val, n_x);
-        OUTVECTOR(y_val_obj, y_val, n_x);
-        OUTVECTOR(z_val_obj, z_val, n_x);
-        OUTVECTOR(sldn_val_obj, sldn_val, n_x);
-        OUTVECTOR(mx_val_obj, mx_val, n_x);
-        OUTVECTOR(my_val_obj, my_val, n_x);
-        OUTVECTOR(mz_val_obj, mz_val, n_x);
-        OUTVECTOR(vol_pix_obj, vol_pix, n_x);
-        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);
-        return PyCapsule_New(sld2i, "GenI", del_sld2i);
+        PyObject *obj;
+        GenI* sld2i;
+
+        //printf("new GenI\n");
+        if (!PyArg_ParseTuple(args, "iOOOOOOOOddd", &is_avg, &x_val_obj, &y_val_obj, &z_val_obj, &sldn_val_obj, &mx_val_obj, &my_val_obj, &mz_val_obj, &vol_pix_obj, &inspin, &outspin, &stheta)) return NULL;
+        INVECTOR(x_val_obj, x_val, n_x);
+        INVECTOR(y_val_obj, y_val, n_y);
+        INVECTOR(z_val_obj, z_val, n_z);
+        INVECTOR(sldn_val_obj, sldn_val, n_sld);
+        INVECTOR(mx_val_obj, mx_val, n_mx);
+        INVECTOR(my_val_obj, my_val, n_my);
+        INVECTOR(mz_val_obj, mz_val, n_mz);
+        INVECTOR(vol_pix_obj, vol_pix, n_vol_pix);
+        sld2i = PyMem_Malloc(sizeof(GenI));
+        //printf("sldi:%p\n", sld2i);
+        if (sld2i != NULL) {
+                initGenI(sld2i,is_avg,(int)n_x,x_val,y_val,z_val,sldn_val,mx_val,my_val,mz_val,vol_pix,inspin,outspin,stheta);
+        }
+        obj = PyCapsule_New(sld2i, "GenI", del_sld2i);
+        //printf("constructed %p\n", obj);
+        return obj;
 }
 
@@ -86 +94 @@
  * GenI the given input (2D) according to a given object
  */
-PyObject * genicom_inputXY(PyObject *, PyObject *args) {
-        int npoints;
+PyObject * genicom_inputXY(PyObject *self, PyObject *args) {
+        PyObject *gen_obj;
         PyObject *qx_obj;
+        PyObject *qy_obj;
+        PyObject *I_out_obj;
+        Py_ssize_t n_qx, n_qy, n_out;
         double *qx;
-        PyObject *qy_obj;
         double *qy;
-        PyObject *I_out_obj;
-        Py_ssize_t n_out;
         double *I_out;
-        PyObject *gen_obj;
-
-        if (!PyArg_ParseTuple(args, "OiOOO",  &gen_obj, &npoints, &qx_obj, &qy_obj, &I_out_obj)) return NULL;
-        OUTVECTOR(qx_obj, qx, n_out);
-        OUTVECTOR(qy_obj, qy, n_out);
+        GenI* sld2i;
+
+        //printf("in genicom_inputXY\n");
+        if (!PyArg_ParseTuple(args, "OOOO",  &gen_obj, &qx_obj, &qy_obj, &I_out_obj)) return NULL;
+        sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI");
+        INVECTOR(qx_obj, qx, n_qx);
+        INVECTOR(qy_obj, qy, n_qy);
         OUTVECTOR(I_out_obj, I_out, n_out);
+        //printf("qx, qy, I_out: %d %d %d, %d %d %d\n", qx, qy, I_out, n_qx, n_qy, n_out);
 
         // Sanity check
-        //if(n_in!=n_out) return Py_BuildValue("i",-1);
-
-        // Set the array pointers
-        void *temp = PyCapsule_GetPointer(gen_obj, "GenI");
-        GenI* s = static_cast<GenI *>(temp);
-
-        s->genicomXY(npoints, qx, qy, I_out);
+        //if(n_q!=n_out) return Py_BuildValue("i",-1);
+
+        genicomXY(sld2i, (int)n_qx, qx, qy, I_out);
+        //printf("done calc\n");
         //return PyCObject_FromVoidPtr(s, del_genicom);
         return Py_BuildValue("i",1);
@@ -117 +125 @@
  * GenI the given 1D input according to a given object
  */
-PyObject * genicom_input(PyObject *, PyObject *args) {
-        int npoints;
+PyObject * genicom_input(PyObject *self, PyObject *args) {
+        PyObject *gen_obj;
         PyObject *q_obj;
+        PyObject *I_out_obj;
+        Py_ssize_t n_q, n_out;
         double *q;
-        PyObject *I_out_obj;
-        Py_ssize_t n_out;
         double *I_out;
-        PyObject *gen_obj;
-
-        if (!PyArg_ParseTuple(args, "OiOO",  &gen_obj, &npoints, &q_obj, &I_out_obj)) return NULL;
-        OUTVECTOR(q_obj, q, n_out);
+        GenI *sld2i;
+
+        if (!PyArg_ParseTuple(args, "OOO",  &gen_obj, &q_obj, &I_out_obj)) return NULL;
+        sld2i = (GenI *)PyCapsule_GetPointer(gen_obj, "GenI");
+        INVECTOR(q_obj, q, n_q);
         OUTVECTOR(I_out_obj, I_out, n_out);
 
         // Sanity check
-        //if(n_in!=n_out) return Py_BuildValue("i",-1);
-
-        // Set the array pointers
-        void *temp = PyCapsule_GetPointer(gen_obj, "GenI");
-        GenI* s = static_cast<GenI *>(temp);
-
-        s->genicom(npoints, q, I_out);
-        //return PyCObject_FromVoidPtr(s, del_genicom);
+        //if (n_q!=n_out) return Py_BuildValue("i",-1);
+
+        genicom(sld2i, (int)n_q, q, I_out);
         return Py_BuildValue("i",1);
 }

src/sas/sascalc/calculator/sas_gen.py

@@ -118 +118 @@
         self.is_avg = is_avg
 
-    def _gen(self, x, y, i):
+    def _gen(self, qx, qy):
         """
         Evaluate the function
@@ -129 +129 @@
         pos_y = self.data_y
         pos_z = self.data_z
-        len_x = len(pos_x)
         if self.is_avg is None:
-            len_x *= -1
             pos_x, pos_y, pos_z = transform_center(pos_x, pos_y, pos_z)
-        len_q = len(x)
         sldn = copy.deepcopy(self.data_sldn)
         sldn -= self.params['solvent_SLD']
-        model = mod.new_GenI(len_x, pos_x, pos_y, pos_z,
-                             sldn, self.data_mx, self.data_my,
-                             self.data_mz, self.data_vol,
-                             self.params['Up_frac_in'],
-                             self.params['Up_frac_out'],
-                             self.params['Up_theta'])
-        if y == []:
-            mod.genicom(model, len_q, x, i)
-        else:
-            mod.genicomXY(model, len_q, x, y, i)
+        # **** WARNING **** new_GenI holds pointers to numpy vectors
+        # be sure that they are contiguous double precision arrays and make 
+        # sure the GC doesn't eat them before genicom is called.
+        # TODO: rewrite so that the parameters are passed directly to genicom
+        args = (
+            (1 if self.is_avg else 0),
+            pos_x, pos_y, pos_z,
+            sldn, self.data_mx, self.data_my,
+            self.data_mz, self.data_vol,
+            self.params['Up_frac_in'],
+            self.params['Up_frac_out'],
+            self.params['Up_theta'])
+        model = mod.new_GenI(*args)
+        if len(qy):
+            qx, qy = _vec(qx), _vec(qy)
+            I_out = np.empty_like(qx)
+            #print("npoints", qx.shape, "npixels", pos_x.shape)
+            mod.genicomXY(model, qx, qy, I_out)
+            #print("I_out after", I_out)
+        else:
+            qx = _vec(qx)
+            I_out = np.empty_like(qx)
+            mod.genicom(model, qx, I_out)
         vol_correction = self.data_total_volume / self.params['total_volume']
-        return  self.params['scale'] * vol_correction * i + \
-                        self.params['background']
+        result = (self.params['scale'] * vol_correction * I_out
+                  + self.params['background'])
+        return result
 
     def set_sld_data(self, sld_data=None):
@@ -156 +167 @@
         self.sld_data = sld_data
         self.data_pos_unit = sld_data.pos_unit
-        self.data_x = sld_data.pos_x
-        self.data_y = sld_data.pos_y
-        self.data_z = sld_data.pos_z
-        self.data_sldn = sld_data.sld_n
-        self.data_mx = sld_data.sld_mx
-        self.data_my = sld_data.sld_my
-        self.data_mz = sld_data.sld_mz
-        self.data_vol = sld_data.vol_pix
+        self.data_x = _vec(sld_data.pos_x)
+        self.data_y = _vec(sld_data.pos_y)
+        self.data_z = _vec(sld_data.pos_z)
+        self.data_sldn = _vec(sld_data.sld_n)
+        self.data_mx = _vec(sld_data.sld_mx)
+        self.data_my = _vec(sld_data.sld_my)
+        self.data_mz = _vec(sld_data.sld_mz)
+        self.data_vol = _vec(sld_data.vol_pix)
         self.data_total_volume = sum(sld_data.vol_pix)
         self.params['total_volume'] = sum(sld_data.vol_pix)
@@ -180 +191 @@
         :return: (I value)
         """
-        if x.__class__.__name__ == 'list':
+        if isinstance(x, list):
             if len(x[1]) > 0:
                 msg = "Not a 1D."
                 raise ValueError(msg)
-            i_out = np.zeros_like(x[0])
             # 1D I is found at y =0 in the 2D pattern
-            out = self._gen(x[0], [], i_out)
+            out = self._gen(x[0], [])
             return out
         else:
@@ -199 +209 @@
         :Use this runXY() for the computation
         """
-        if x.__class__.__name__ == 'list':
-            i_out = np.zeros_like(x[0])
-            out = self._gen(x[0], x[1], i_out)
-            return out
+        if isinstance(x, list):
+            return self._gen(x[0], x[1])
         else:
             msg = "Q must be given as list of qx's and qy's"
@@ -214 +222 @@
                       where qx,qy are 1D ndarrays (for 2D).
         """
-        if qdist.__class__.__name__ == 'list':
-            if len(qdist[1]) < 1:
-                out = self.run(qdist)
-            else:
-                out = self.runXY(qdist)
-            return out
+        if isinstance(qdist, list):
+            return self.run(qdist) if len(qdist[1]) < 1 else self.runXY(qdist)
         else:
             mesg = "evalDistribution is expecting an ndarray of "
             mesg += "a list [qx,qy] where qx,qy are arrays."
             raise RuntimeError(mesg)
+
+def _vec(v):
+    return np.ascontiguousarray(v, 'd')
 
 class OMF2SLD(object):
@@ -1041 +1048 @@
         self.line_z = line_z
 
+def _get_data_path(*path_parts):
+    from os.path import realpath, join as joinpath, dirname, abspath
+    # in sas/sascalc/calculator;  want sas/sasview/test
+    return joinpath(dirname(realpath(__file__)),
+                    '..', '..', 'sasview', 'test', *path_parts)
+
 def test_load():
     """
@@ -1046 +1059 @@
     """
     from mpl_toolkits.mplot3d import Axes3D
-    current_dir = os.path.abspath(os.path.curdir)
-    print(current_dir)
-    for i in range(6):
-        current_dir, _ = os.path.split(current_dir)
-        tfile = os.path.join(current_dir, "test", "CoreXY_ShellZ.txt")
-        ofile = os.path.join(current_dir, "test", "A_Raw_Example-1.omf")
-        if os.path.isfile(tfile):
-            tfpath = tfile
-            ofpath = ofile
-            break
+    tfpath = _get_data_path("1d_data", "CoreXY_ShellZ.txt")
+    ofpath = _get_data_path("coordinate_data", "A_Raw_Example-1.omf")
+    if not os.path.isfile(tfpath) or not os.path.isfile(ofpath):
+        raise ValueError("file(s) not found: %r, %r"%(tfpath, ofpath))
     reader = SLDReader()
     oreader = OMFReader()
-    output = decode(reader.read(tfpath))
-    ooutput = decode(oreader.read(ofpath))
+    output = reader.read(tfpath)
+    ooutput = oreader.read(ofpath)
     foutput = OMF2SLD()
     foutput.set_data(ooutput)
@@ -1088 +1095 @@
     plt.show()
 
+def test_save():
+    ofpath = _get_data_path("coordinate_data", "A_Raw_Example-1.omf")
+    if not os.path.isfile(ofpath):
+        raise ValueError("file(s) not found: %r"%(ofpath,))
+    oreader = OMFReader()
+    omfdata = oreader.read(ofpath)
+    omf2sld = OMF2SLD()
+    omf2sld.set_data(omfdata)
+    writer = SLDReader()
+    writer.write("out.txt", omf2sld.output)
+
 def test():
     """
         Test code
     """
-    current_dir = os.path.abspath(os.path.curdir)
-    for i in range(3):
-        current_dir, _ = os.path.split(current_dir)
-        ofile = os.path.join(current_dir, "test", "A_Raw_Example-1.omf")
-        if os.path.isfile(ofile):
-            ofpath = ofile
-            break
+    ofpath = _get_data_path("coordinate_data", "A_Raw_Example-1.omf")
+    if not os.path.isfile(ofpath):
+        raise ValueError("file(s) not found: %r"%(ofpath,))
     oreader = OMFReader()
-    ooutput = decode(oreader.read(ofpath))
-    foutput = OMF2SLD()
-    foutput.set_data(ooutput)
-    writer = SLDReader()
-    writer.write(os.path.join(os.path.dirname(ofpath), "out.txt"),
-                 foutput.output)
+    omfdata = oreader.read(ofpath)
+    omf2sld = OMF2SLD()
+    omf2sld.set_data(omfdata)
     model = GenSAS()
-    model.set_sld_data(foutput.output)
-    x = np.arange(1000)/10000. + 1e-5
-    y = np.arange(1000)/10000. + 1e-5
-    i = np.zeros(1000)
-    model.runXY([x, y, i])
+    model.set_sld_data(omf2sld.output)
+    x = np.linspace(0, 0.1, 11)[1:]
+    return model.runXY([x, x])
 
 if __name__ == "__main__":
+    #test_load()
+    #test_save()
+    #print(test())
     test()
-    test_load()

src/sas/sascalc/dataloader/file_reader_base_class.py

@@ -27 +27 @@
 
 class FileReader(object):
-    # List of Data1D and Data2D objects to be sent back to data_loader
-    output = []
-    # Current plottable_(1D/2D) object being loaded in
-    current_dataset = None
-    # Current DataInfo object being loaded in
-    current_datainfo = None
     # String to describe the type of data this reader can load
     type_name = "ASCII"
@@ -43 +37 @@
     # Able to import the unit converter
     has_converter = True
-    # Open file handle
-    f_open = None
     # Default value of zero
     _ZERO = 1e-16
 
+    def __init__(self):
+        # List of Data1D and Data2D objects to be sent back to data_loader
+        self.output = []
+        # Current plottable_(1D/2D) object being loaded in
+        self.current_dataset = None
+        # Current DataInfo object being loaded in
+        self.current_datainfo = None
+        # File path sent to reader
+        self.filepath = None
+        # Open file handle
+        self.f_open = None
+
     def read(self, filepath):
         """
@@ -54 +58 @@
         :param filepath: The full or relative path to a file to be loaded
         """
+        self.filepath = filepath
         if os.path.isfile(filepath):
             basename, extension = os.path.splitext(os.path.basename(filepath))
@@ -96 +101 @@
         self.current_datainfo = None
         self.current_dataset = None
+        self.filepath = None
         self.output = []
 

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

@@ -82 +82 @@
 
     def read(self, xml_file, schema_path="", invalid=True):
-        if schema_path != "" or invalid != True:
+        if schema_path != "" or not invalid:
             # read has been called from self.get_file_contents because xml file doens't conform to schema
             _, self.extension = os.path.splitext(os.path.basename(xml_file))
@@ -942 +942 @@
             pos, "z", datainfo.sample.position.z,
             {"unit": datainfo.sample.position_unit})
-        if written == True:
+        if written:
             self.append(pos, sample)
 
@@ -955 +955 @@
             ori, "yaw", datainfo.sample.orientation.z,
             {"unit": datainfo.sample.orientation_unit})
-        if written == True:
+        if written:
             self.append(ori, sample)
 
@@ -1002 +1002 @@
             size, "z", datainfo.source.beam_size.z,
             {"unit": datainfo.source.beam_size_unit})
-        if written == True:
+        if written:
             self.append(size, source)
 
@@ -1058 +1058 @@
                     size, "z", aperture.size.z,
                     {"unit": aperture.size_unit})
-                if written == True:
+                if written:
                     self.append(size, apert)
 
@@ -1081 +1081 @@
             written = written | self.write_node(det, "SDD", item.distance,
                                                 {"unit": item.distance_unit})
-            if written == True:
+            if written:
                 self.append(det, instr)
 
@@ -1091 +1091 @@
             written = written | self.write_node(off, "z", item.offset.z,
                                                 {"unit": item.offset_unit})
-            if written == True:
+            if written:
                 self.append(off, det)
 
@@ -1103 +1103 @@
                                                 item.orientation.z,
                                                 {"unit": item.orientation_unit})
-            if written == True:
+            if written:
                 self.append(ori, det)
 
@@ -1115 +1115 @@
                                                 item.beam_center.z,
                                                 {"unit": item.beam_center_unit})
-            if written == True:
+            if written:
                 self.append(center, det)
 
@@ -1125 +1125 @@
             written = written | self.write_node(pix, "z", item.pixel_size.z,
                                                 {"unit": item.pixel_size_unit})
-            if written == True:
+            if written:
                 self.append(pix, det)
             self.write_node(det, "slit_length", item.slit_length,

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

@@ -157 +157 @@
         # Store all data
         # Store wavelength
-        if has_converter == True and self.current_datainfo.source.wavelength_unit != 'A':
+        if has_converter and self.current_datainfo.source.wavelength_unit != 'A':
             conv = Converter('A')
             wavelength = conv(wavelength,
@@ -164 +164 @@
 
         # Store distance
-        if has_converter == True and detector.distance_unit != 'm':
+        if has_converter and detector.distance_unit != 'm':
             conv = Converter('m')
             distance = conv(distance, units=detector.distance_unit)
@@ -170 +170 @@
 
         # Store pixel size
-        if has_converter == True and detector.pixel_size_unit != 'mm':
+        if has_converter and detector.pixel_size_unit != 'mm':
             conv = Converter('mm')
             pixel = conv(pixel, units=detector.pixel_size_unit)

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

@@ -12 +12 @@
 from ..file_reader_base_class import FileReader
 from ..data_info import plottable_1D, DataInfo
-from ..loader_exceptions import FileContentsException, DataReaderException
+from ..loader_exceptions import FileContentsException
 
 # Check whether we have a converter available
@@ -18 +18 @@
 try:
     from sas.sascalc.data_util.nxsunit import Converter
-except:
+except ImportError:
     has_converter = False
 _ZERO = 1e-16
@@ -46 +46 @@
         line = self.nextline()
         params = {}
-        while not line.startswith("BEGIN_DATA"):
+        while line and not line.startswith("BEGIN_DATA"):
             terms = line.split()
             if len(terms) >= 2:
@@ -63 +63 @@
             raise FileContentsException("Wavelength has no units")
         if params["SpinEchoLength_unit"] != params["Wavelength_unit"]:
-            raise FileContentsException("The spin echo data has rudely used "
-                               "different units for the spin echo length "
-                               "and the wavelength.  While sasview could "
-                               "handle this instance, it is a violation "
-                               "of the file format and will not be "
-                               "handled by other software.")
+            raise FileContentsException(
+                "The spin echo data has rudely used "
+                "different units for the spin echo length "
+                "and the wavelength.  While sasview could "
+                "handle this instance, it is a violation "
+                "of the file format and will not be "
+                "handled by other software.")
 
         headers = self.nextline().split()
@@ -86 +87 @@
 
         if not data.size:
-            raise FileContentsException("{} is empty".format(path))
+            raise FileContentsException("{} is empty".format(self.filepath))
         x = data[:, headers.index("SpinEchoLength")]
         if "SpinEchoLength_error" in headers:

src/sas/sascalc/fit/MultiplicationModel.py

@@ -68 +68 @@
         try:
             multiplicity = p_model.multiplicity
-        except:
+        except AttributeError:
             multiplicity = 1
         ## functional multiplicity of the model
@@ -76 +76 @@
         self.non_fittable = p_model.non_fittable
         self.multiplicity_info = []
-        self.fun_list = {}
+        self.fun_list = []
         if self.non_fittable > 1:
             try:
@@ -82 +82 @@
                 self.fun_list = p_model.fun_list
                 self.is_multiplicity_model = True
-            except:
+            except AttributeError:
                 pass
         else:

src/sas/sascalc/fit/qsmearing.py

@@ -90 +90 @@
             #print "data1D.dx[0]",data1D.dx[0],data1D.dxl[0]
     # If we found resolution smearing data, return a QSmearer
-    if _found_resolution == True:
+    if _found_resolution:
          return pinhole_smear(data, model)
 
@@ -113 +113 @@
                 break
     # If we found slit smearing data, return a slit smearer
-    if _found_slit == True:
+    if _found_slit:
         return slit_smear(data, model)
     return None

src/sas/sascalc/pr/invertor.py

@@ -222 +222 @@
         elif name == 'est_bck':
             value = self.get_est_bck()
-            if value == 1:
-                return True
-            else:
-                return False
+            return value == 1
         elif name in self.__dict__:
             return self.__dict__[name]
@@ -460 +457 @@
 
         # If we need to fit the background, add a term
-        if self.est_bck == True:
+        if self.est_bck:
             nfunc_0 = nfunc
             nfunc += 1
@@ -506 +503 @@
 
         # Keep a copy of the last output
-        if self.est_bck == False:
+        if not self.est_bck:
             self.out = c
             self.cov = err
@@ -658 +655 @@
         file.write("#slit_width=%g\n" % self.slit_width)
         file.write("#background=%g\n" % self.background)
-        if self.est_bck == True:
+        if self.est_bck:
             file.write("#has_bck=1\n")
         else:
@@ -738 +735 @@
                     elif line.startswith('#has_bck='):
                         toks = line.split('=')
-                        if int(toks[1]) == 1:
-                            self.est_bck = True
-                        else:
-                            self.est_bck = False
+                        self.est_bck = int(toks[1]) == 1
 
                     # Now read in the parameters

src/sas/sascalc/pr/num_term.py

@@ -55 +55 @@
         medi = 0
         for i in range(dv):
-            if odd == True:
+            if odd:
                 medi = osc[int(med)]
             else:
@@ -98 +98 @@
                 new_osc3.append(self.osc_list[i])
 
-        if flag9 == True:
+        if flag9:
             self.dataset = new_osc1
-        elif flag8 == True:
+        elif flag8:
             self.dataset = new_osc2
         else:
@@ -141 +141 @@
             div = len(nts)
             tem = float(div) / 2.0
-            odd = self.is_odd(div)
-            if odd == True:
+            if self.is_odd(div):
                 nt = nts[int(tem)]
             else:
@@ -148 +147 @@
             return nt, self.alpha_list[nt - 10], self.mess_list[nt - 10]
         except:
-            #TODO: check the logic above and make sure it doesn't 
+            #TODO: check the logic above and make sure it doesn't
             # rely on the try-except.
             return self.nterm_min, self.invertor.alpha, ''