Changeset 8f20419d in sasview for sansmodels/src/sans

Timestamp:

Oct 14, 2010 2:30:23 PM (14 years ago)

Author:

Jae Cho <jhjcho@…>

Branches:

master, ESS_GUI, ESS_GUI_Docs, ESS_GUI_batch_fitting, ESS_GUI_bumps_abstraction, ESS_GUI_iss1116, ESS_GUI_iss879, ESS_GUI_iss959, ESS_GUI_opencl, ESS_GUI_ordering, ESS_GUI_sync_sascalc, costrafo411, magnetic_scatt, release-4.1.1, release-4.1.2, release-4.2.2, release_4.0.1, ticket-1009, ticket-1094-headless, ticket-1242-2d-resolution, ticket-1243, ticket-1249, ticket885, unittest-saveload

Children:

29100cb

Parents:

4cc8285c

Message:

more models and some tests

Location:

sansmodels/src/sans/models

Files:

• BroadPeakModel.py (added)
• CorrLengthModel.py (added)
• FractalCoreShellModel.py (added)
• GaussLorentzGelModel.py (added)
• GuinierPorodModel.py (added)
• ReflectivityModel.py (added)
• TwoLorentzianModel.py (added)
• TwoPowerLawModel.py (added)
• c_extensions/bcc.c (modified) (1 diff)
• c_extensions/ellipsoid.c (modified) (2 diffs)
• c_extensions/fcc.c (modified) (2 diffs)
• c_extensions/sc.c (modified) (1 diff)
• c_extensions/triaxial_ellipsoid.c (modified) (1 diff)
• test/utest_extra_models.py (modified) (1 diff)

sansmodels/src/sans/models/c_extensions/bcc.c

@@ -91 +91 @@
     b1_y = cos(pars->psi);
     // b2 axis orientation
-    b2_x = sqrt(1-sin(pars->theta)*cos(pars->phi))*cos(pars->psi);
-    b2_y = sqrt(1-sin(pars->theta)*cos(pars->phi))*sin(pars->psi);
+    b2_x = sqrt(1.0-sin(pars->theta)*cos(pars->phi))*cos(pars->psi);
+    b2_y = sqrt(1.0-sin(pars->theta)*cos(pars->phi))*sin(pars->psi);
 
     // a3 axis orientation

sansmodels/src/sans/models/c_extensions/ellipsoid.c

@@ -32 +32 @@
 
         // Spherical scattering ampliture, with modified length for ellipsoid
-        sph_func = 3*( sin(q*length) - q*length*cos(q*length) ) / (q*q*q*length*length*length);
+        sph_func = 3.0*( sin(q*length) - q*length*cos(q*length) ) / (q*q*q*length*length*length);
 
         return sph_func*sph_func;
@@ -99 +99 @@
 
     // q vector
-    q_z = 0;
+    q_z = 0.0;
 
     // Compute the angle btw vector q and the

sansmodels/src/sans/models/c_extensions/fcc.c

@@ -91 +91 @@
     b1_y = cos(pars->psi);
     // b2 axis orientation
-    b2_x = sqrt(1-sin(pars->theta)*cos(pars->phi))*cos(pars->psi);
-    b2_y = sqrt(1-sin(pars->theta)*cos(pars->phi))*sin(pars->psi);
+    b2_x = sqrt(1.0-sin(pars->theta)*cos(pars->phi))*cos(pars->psi);
+    b2_y = sqrt(1.0-sin(pars->theta)*cos(pars->phi))*sin(pars->psi);
 
     // a3 axis orientation
@@ -109 +109 @@
 
     // Compute the angle btw vector q and the a3 axis
-    cos_val_a3 = a3_x*q_x + a3_y*q_y + a3_z*q_z;
+    cos_val_a3 = a3_x*q_x + a3_y*q_y;// + a3_z*q_z;
     a3_dot_q = aa*q*cos_val_a3;
 

sansmodels/src/sans/models/c_extensions/sc.c

@@ -99 +99 @@
 
     // a2 axis orientation
-    a2_x = sqrt(1-sin(pars->theta)*cos(pars->phi))*cos(pars->psi);
-    a2_y = sqrt(1-sin(pars->theta)*cos(pars->phi))*sin(pars->psi);
+    a2_x = sqrt(1.0-sin(pars->theta)*cos(pars->phi))*cos(pars->psi);
+    a2_y = sqrt(1.0-sin(pars->theta)*cos(pars->phi))*sin(pars->psi);
     // a2 axis
-    cos_val_a2 = sin(acos(cos_val_a1)) ;
+    cos_val_a2 =  a2_x*q_x + a2_y*q_y;//sin(acos(cos_val_a1)) ;
     a2_dot_q = aa*q*cos_val_a2;
 

sansmodels/src/sans/models/c_extensions/triaxial_ellipsoid.c

@@ -97 +97 @@
 
     // q vector
-    q_z = 0;
+    q_z = 0.0;
 
         //dx = 1.0;

sansmodels/src/sans/models/test/utest_extra_models.py

@@ -178 +178 @@
         self.assertAlmostEqual(self.model.run(0.215268), 0.00927739, 6)
         self.assertAlmostEqual(self.model.runXY(0.414467), 0.000406973, 6)
-                                                        
+                               
+
+class TestGuinierPorod(unittest.TestCase):
+    """
+    Unit tests for GuinierPorod Model function
+    """
+    def setUp(self):
+        from sans.models.GuinierPorodModel import GuinierPorodModel 
+        self.model= GuinierPorodModel()
+        
+    def test1D(self):        
+        # the values are from Igor pro calculation  
+        # the different digits are due to precision of q values  
+        self.assertAlmostEqual(self.model.run(0.001), 995.112, 3)
+        self.assertAlmostEqual(self.model.run(0.105363), 0.162904, 5)
+        self.assertAlmostEqual(self.model.runXY(0.441623), 0.100854, 6)
+
+class TestGaussLorentzGel(unittest.TestCase):
+    """
+    Unit tests for GuinierPorod Model function
+    """
+    def setUp(self):
+        from sans.models.GaussLorentzGelModel import GaussLorentzGelModel
+        self.model= GaussLorentzGelModel()
+        
+    def test1D(self):        
+        # the values are from Igor pro calculation  
+        # the different digits are due to precision of q values  
+        self.assertAlmostEqual(self.model.run(0.001), 149.481, 3)
+        self.assertAlmostEqual(self.model.run(0.105363), 9.1903, 4)
+        self.assertAlmostEqual(self.model.runXY(0.441623), 0.632811, 5)
+                                
+
+class TestTwoPowerLaw(unittest.TestCase):
+    """
+    Unit tests for TwoPowerLaw Model function
+    """
+    def setUp(self):
+        from sans.models.TwoPowerLawModel import TwoPowerLawModel
+        self.model= TwoPowerLawModel()
+        
+    def test1D(self):        
+        # the values are from Igor pro calculation  
+        # the different digits are due to precision of q values  
+        self.assertEqual(self.model.run(0.001), 1000)
+        self.assertAlmostEqual(self.model.run(0.150141), 0.125945, 5)
+        self.assertAlmostEqual(self.model.runXY(0.442528), 0.00166884, 7)
+                                
+class TestTwoLorentzian(unittest.TestCase):
+    """
+    Unit tests for TwoLorentzian Model function
+    """
+    def setUp(self):
+        from sans.models.TwoLorentzianModel import TwoLorentzianModel
+        self.model= TwoLorentzianModel()
+        
+    def test1D(self):        
+        # the values are from Igor pro calculation  
+        # the different digits are due to precision of q values  
+        self.assertAlmostEqual(self.model.run(0.001), 11.0899, 3)
+        self.assertAlmostEqual(self.model.run(0.150141), 0.410245, 5)
+        self.assertAlmostEqual(self.model.runXY(0.442528), 0.148699, 6)
+                                
+
+class TestCorrLengthLaw(unittest.TestCase):
+    """
+    Unit tests for CorrLength Model function
+    """
+    def setUp(self):
+        from sans.models.CorrLengthModel import CorrLengthModel
+        self.model= CorrLengthModel()
+        
+    def test1D(self):        
+        # the values are from Igor pro calculation  
+        # the different digits are due to precision of q values  
+        self.assertAlmostEqual(self.model.run(0.001), 1010.08, 1)
+        self.assertAlmostEqual(self.model.run(0.150141), 0.274645, 5)
+        self.assertAlmostEqual(self.model.runXY(0.442528), 0.120396, 6)
+                                
+
+class TestBroadPeak(unittest.TestCase):
+    """
+    Unit tests for BroadPeak Model function
+    """
+    def setUp(self):
+        from sans.models.BroadPeakModel import BroadPeakModel
+        self.model= BroadPeakModel()
+        
+    def test1D(self):        
+        # the values are from Igor pro calculation  
+        # the different digits are due to precision of q values  
+        self.assertAlmostEqual(self.model.run(0.001), 10000.5, 1)
+        self.assertAlmostEqual(self.model.run(0.1501412), 1.47557, 5)
+        self.assertAlmostEqual(self.model.runXY(0.4425284), 0.134093, 6)
+        
+class TestFractalCoreShell(unittest.TestCase):
+    """
+    Unit tests for FractalCoreShell Model function
+    """
+    def setUp(self):
+        from sans.models.FractalCoreShellModel import FractalCoreShellModel
+        self.model= FractalCoreShellModel()
+        
+    def test1D(self):        
+        #self.model.setParam('radius.width', 2.0)
+        # the values are from Igor pro calculation  
+        # the different digits are due to precision of q values  
+        self.assertAlmostEqual(self.model.run(0.001), 273.742, 3)
+        self.assertAlmostEqual(self.model.run(0.1501412), 0.040079, 6)
+        self.assertAlmostEqual(self.model.runXY(0.4425284), 0.00141167, 6)                             
+                                                                                                               
 if __name__ == '__main__':
     unittest.main()