source: sasview/sansmodels/src/sans/models/test/utest_extra_models.py @ 339ce67

"""
Unit tests for extra models,PolymerexclVolume, RPA10Model
The reference values are calculated on IGOR/NIST package(Oct.,2010)
@author: JHJ Cho / UTK
"""
import unittest
class TestPolymerExclVolume(unittest.TestCase):
    """
    Unit tests for PolymerexclVolume (non-shape) function
    """
    def setUp(self):
        from sans.models.PolymerExclVolume import PolymerExclVolume
        self.model= PolymerExclVolume()
        
    def test1D(self):          
        # the values are from Igor pro calculation    
        self.assertAlmostEqual(self.model.run(0.001), 0.998801, 6)
        self.assertAlmostEqual(self.model.run(0.21571), 0.00192041, 6)
        self.assertAlmostEqual(self.model.runXY(0.41959), 0.000261302, 6)
        
class TestRPA10Case(unittest.TestCase):
    """
    Unit tests for RPA10Model (non-shape) function
    """
    def setUp(self):
        from sans.models.RPA10Model import RPA10Model
        self.model0= RPA10Model(0)
        self.model1= RPA10Model(1)
        self.model2= RPA10Model(2)
        self.model3= RPA10Model(3)
        self.model4= RPA10Model(4)
        self.model5= RPA10Model(5)
        self.model6= RPA10Model(6)
        self.model7= RPA10Model(7)
        self.model8= RPA10Model(8)
        self.model9= RPA10Model(9)
        
    def test1D(self):          
        # the test values are from Igor pro calculation   
        # case 0 
        # set default of vol fration consistent with IGor
        self.model0.setParam('Phic',0.5)
        self.model0.setParam('Phid',0.5)
        self.assertAlmostEqual(self.model0.run(0.001), 0.0716863, 6)
        self.assertAlmostEqual(self.model0.runXY(0.414955), 0.00396997, 6)
        # case 1
        # set default of vol fration consistent with IGor
        self.model1.setParam('Phic',0.5)
        self.model1.setParam('Phid',0.5)
        self.assertAlmostEqual(self.model1.run(0.001), 0.00395016, 6)
        self.assertAlmostEqual(self.model1.runXY(0.414955), 0.00396735, 6)
        # case 2 
        # set default of vol fration consistent with IGor
        self.model2.setParam('Phib',0.33)
        self.model2.setParam('Phic',0.33)
        self.model2.setParam('Phid',0.33)
        self.assertAlmostEqual(self.model2.run(0.001), 0.0932902, 6)
        self.assertAlmostEqual(self.model2.runXY(0.414955), 0.00355736, 6)
        # case 3
        # set default of vol fration consistent with IGor
        self.model3.setParam('Phib',0.33)
        self.model3.setParam('Phic',0.33)
        self.model3.setParam('Phid',0.33)
        self.assertAlmostEqual(self.model3.run(0.001), 0.026254, 6)
        self.assertAlmostEqual(self.model3.runXY(0.414955), 0.00355577, 6)
        # case 4
        # set default of vol fration consistent with IGor
        self.model4.setParam('Phib',0.33)
        self.model4.setParam('Phic',0.33)
        self.model4.setParam('Phid',0.33)
        self.assertAlmostEqual(self.model4.run(0.001), 0.0067433, 6)
        self.assertAlmostEqual(self.model4.runXY(0.414955), 0.00355656, 6)
        # case 5
        self.assertAlmostEqual(self.model5.run(0.001), 0.102636, 6)
        self.assertAlmostEqual(self.model5.runXY(0.414955), 0.00305812, 6)
        # case 6
        self.assertAlmostEqual(self.model6.run(0.001), 0.0370357, 6)
        self.assertAlmostEqual(self.model6.runXY(0.414955), 0.00305708, 6)
        # case 7
        self.assertAlmostEqual(self.model7.run(0.001), 0.0167775, 6)
        self.assertAlmostEqual(self.model7.runXY(0.414955), 0.00305743, 6)
        # case 8
        self.assertAlmostEqual(self.model8.run(0.001), 0.0378691, 6)
        self.assertAlmostEqual(self.model8.runXY(0.414955), 0.00305743, 6)
        # case 9
        self.assertAlmostEqual(self.model9.run(0.001), 0.00839376, 6)
        self.assertAlmostEqual(self.model9.runXY(0.414955), 0.00305777, 6)  
              
class TestBarBell(unittest.TestCase):
    """
    Unit tests for BarBell function
    """
    def setUp(self):
        from sans.models.BarBellModel import BarBellModel
        self.model= BarBellModel()
        
    def test1D(self):          
        # the values are from Igor pro calculation    
        self.assertAlmostEqual(self.model.run(0.001), 2864.7, 1)
        self.assertAlmostEqual(self.model.run(0.215268), 0.526351, 4)
        self.assertAlmostEqual(self.model.runXY(0.414467), 0.0685892, 6)

class TestCappedCylinder(unittest.TestCase):
    """
    Unit tests for CappedCylinder function
    """
    def setUp(self):
        from sans.models.CappedCylinderModel import CappedCylinderModel
        self.model= CappedCylinderModel()
        
    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), 1424.72, 2)
        self.assertAlmostEqual(self.model.run(0.215268), 0.360736, 4)
        self.assertAlmostEqual(self.model.runXY(0.414467), 0.110283, 5)

class TestLamellarParaCrystal(unittest.TestCase):
    """
    Unit tests for LamellarParaCystal function
    """
    def setUp(self):
        from sans.models.LamellarPCrystalModel import LamellarPCrystalModel
        self.model= LamellarPCrystalModel()
        
    def test1D(self):    
        self.model.setParam("pd_spacing", 0.2)      
        # the values are from Igor pro calculation  
        # the different digits are due to precision of q values  
        self.assertAlmostEqual(self.model.run(0.001), 21829.3, 1)
        self.assertAlmostEqual(self.model.run(0.215268), 0.00487686, 6)
        self.assertAlmostEqual(self.model.runXY(0.414467), 0.00062029, 6)


class TestSCParaCrystal(unittest.TestCase):
    """
    Unit tests for Simple Cubic ParaCrystal Model function
    """
    def setUp(self):
        from sans.models.SCCrystalModel import SCCrystalModel
        self.model= SCCrystalModel()
        
    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), 10.3038, 4)
        self.assertAlmostEqual(self.model.run(0.215268), 0.00714905, 6)
        self.assertAlmostEqual(self.model.runXY(0.414467), 0.000313289, 6)

class TestFCParaCrystal(unittest.TestCase):
    """
    Unit tests for Face Centered Cubic ParaCrystal Model function
    """
    def setUp(self):
        from sans.models.FCCrystalModel import FCCrystalModel
        self.model= FCCrystalModel()
        
    def test1D(self):       
        self.model.setParam("d_factor", 0.05)  
        # the values are from Igor pro calculation  
        # the different digits are due to precision of q values  
        self.assertAlmostEqual(self.model.run(0.001), 0.121017, 6)
        self.assertAlmostEqual(self.model.run(0.215268), 0.0107218, 6)
        self.assertAlmostEqual(self.model.runXY(0.414467), 0.000443282, 6)

class TestBCParaCrystal(unittest.TestCase):
    """
    Unit tests for Body Centered Cubic ParaCrystal Model function
    """
    def setUp(self):
        from sans.models.BCCrystalModel import BCCrystalModel
        self.model= BCCrystalModel()
        
    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), 1.77267, 4)
        self.assertAlmostEqual(self.model.run(0.215268), 0.00927739, 6)
        self.assertAlmostEqual(self.model.runXY(0.414467), 0.000406973, 6)
                                                        
if __name__ == '__main__':
    unittest.main()