Changeset 13374be in sasview for test

Timestamp:

Sep 20, 2017 5:55:53 AM (7 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:

fca1f50

Parents:

6d62b7f (diff), 2a399ca (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into 4_1_issues

Location:

test

Files:

• corfunc/test/gamma1_out.txt (added)
• corfunc/test/gamma3_out.txt (added)
• corfunc/test/idf_out.txt (added)
• corfunc/test/utest_corfunc.py (modified) (3 diffs)
• utest_sasview.py (modified) (2 diffs)
• sasdataloader/test/utest_abs_reader.py (modified) (1 diff)

test/corfunc/test/utest_corfunc.py

@@ -2 +2 @@
 Unit Tests for CorfuncCalculator class
 """
+from __future__ import division, print_function
 
 import unittest
 import time
+
 import numpy as np
+
 from sas.sascalc.corfunc.corfunc_calculator import CorfuncCalculator
 from sas.sascalc.dataloader.data_info import Data1D
@@ -14 +17 @@
     def setUp(self):
         self.data = load_data()
+        # Note: to generate target values from the GUI:
+        # * load the data from test/corfunc/test/98929.txt
+        # * set qrange to (0, 0.013), (0.15, 0.24)
+        # * select fourier transform type
+        # * click Calculate Bg
+        # * click Extrapolate
+        # * click Compute Parameters
+        # * copy the Guinier and Porod values to the extrapolate function
+        # * for each graph, grab the data from DataInfo and store it in _out.txt
         self.calculator = CorfuncCalculator(data=self.data, lowerq=0.013,
             upperq=(0.15, 0.24))
+        self.calculator.background = 0.3
         self.extrapolation = None
+        self.transformation = None
+        self.results = [np.loadtxt(filename+"_out.txt").T[2]
+                        for filename in ("gamma1", "gamma3", "idf")]
 
     def extrapolate(self):
-        params, extrapolation = self.calculator.compute_extrapolation()
-
+        params, extrapolation, s2 = self.calculator.compute_extrapolation()
         # Check the extrapolation parameters
-        self.assertAlmostEqual(params['A'], 4.19, places=2)
-        self.assertAlmostEqual(params['B'], -25470, places=0)
-        self.assertAlmostEqual(params['K'], 4.5e-5, places=2)
-        self.assertAlmostEqual(params['sigma'], 2.2e-10, places=2)
+        self.assertAlmostEqual(params['A'], 4.18970, places=5)
+        self.assertAlmostEqual(params['B'], -25469.9, places=1)
+        self.assertAlmostEqual(params['K'], 4.44660e-5, places=10)
+        #self.assertAlmostEqual(params['sigma'], 1.70181e-10, places=15)
 
         # Ensure the extraplation tends to the background value
@@ -57 +72 @@
                 break
 
-    def transform_callback(self, transform):
-        self.assertIsNotNone(transform)
-        self.assertAlmostEqual(transform.y[0], 1)
-        self.assertAlmostEqual(transform.y[-1], 0, 5)
-        self.transformation = transform
+    def transform_callback(self, transforms):
+        transform1, transform3, idf = transforms
+        self.assertIsNotNone(transform1)
+        self.assertAlmostEqual(transform1.y[0], 1)
+        self.assertAlmostEqual(transform1.y[-1], 0, 5)
+        self.transformation = transforms
 
     def extract_params(self):
-        params = self.calculator.extract_parameters(self.transformation)
+        params = self.calculator.extract_parameters(self.transformation[0])
         self.assertIsNotNone(params)
         self.assertEqual(len(params), 6)
         self.assertLess(abs(params['max']-75), 2.5) # L_p ~= 75
 
+    def check_transforms(self):
+        gamma1, gamma3, idf = self.transformation
+        gamma1_out, gamma3_out, idf_out = self.results
+        def compare(a, b):
+            return max(abs((a-b)/b))
+        #print("gamma1 diff", compare(gamma1.y[gamma1.x<=200.], gamma1_out))
+        #print("gamma3 diff", compare(gamma3.y[gamma3.x<=200.], gamma3_out))
+        #print("idf diff", compare(idf.y[idf.x<=200.], idf_out))
+        #self.assertLess(compare(gamma1.y[gamma1.x<=200.], gamma1_out), 1e-10)
+        #self.assertLess(compare(gamma3.y[gamma3.x<=200.], gamma3_out), 1e-10)
+        #self.assertLess(compare(idf.y[idf.x<=200.], idf_out), 1e-10)
+
     # Ensure tests are ran in correct order;
     # Each test depends on the one before it
     def test_calculator(self):
-        steps = [self.extrapolate, self.transform, self.extract_params]
+        steps = [self.extrapolate, self.transform, self.extract_params, self.check_transforms]
         for test in steps:
             try:
                 test()
             except Exception as e:
+                raise
                 self.fail("{} failed ({}: {})".format(test, type(e), e))
 
 
 def load_data(filename="98929.txt"):
-    data = np.loadtxt(filename, dtype=np.float32)
+    data = np.loadtxt(filename, dtype=np.float64)
     q = data[:,0]
     iq = data[:,1]

test/utest_sasview.py

@@ -62 +62 @@
                     proc = subprocess.Popen(code, shell=True, stdout=subprocess.PIPE, stderr = subprocess.STDOUT)
                     std_out, std_err = proc.communicate()
-                    #print std_out
+                    #print(">>>>>> standard out", file_path, "\n", std_out, "\n>>>>>>>>> end stdout", file_path)
                     #sys.exit()
                     m = re.search("Ran ([0-9]+) test", std_out)
@@ -82 +82 @@
                         failed += 1
                         print("Result for %s (%s): FAILED" % (module_name, module_dir))
-                        print(std_out)
+                        #print(std_out)
                     else:
                         passed += 1

test/sasdataloader/test/utest_abs_reader.py

@@ -333 +333 @@
         self.assertEqual(self.data.x[1], 0.03)
         self.assertAlmostEquals(self.data.y[1], 1001.0)
-        self.assertEqual(self.data.dx[0], 0.0)
         self.assertEqual(self.data.dxl[1], 0.005)
         self.assertEqual(self.data.dxw[1], 0.001)