source: sasview/sansmodels/test/utest_other_models.py @ 530cc84

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 530cc84 was dd0d059, checked in by Mathieu Doucet <doucetm@…>, 13 years ago

Trying to see whether this fixes test failure.
  • Property mode set to 100644
File size: 71.4 KB
Line 
1"""
2    Unit tests for specific models.
3    @since: 08/25/2009
4    @note:  The models are running also with numpy array as input.
5            Some models return limit of the function at critical point .
6            So the user should expect finite value for some critical points.
7            Only critical q=0 will be tested.
8           
9            Critical points tests that fail. the user is responsible of changing
10            the model tested or document the failure.
11           
12            Initial values for models are given as the one of Igo software.
13    @author: Gervaise Alina / UTK
14    @summary: Run by G. Alina 10/21/2009
15            Most of the lamellar tests are not passing. Check lamellar im
16            plementation.
17            critial points tested not passing for:
18            - Flexible Cylinder
19            - PeakLorenzt
20            - Squarewell Structure
21            - StickyHstructure
22            - hardSphereStructure
23           
24    @ Note: We don't use matrix for 2D anymore so testEval2D can be ignored (JC)     
25           
26"""
27
28import unittest
29import numpy 
30import math
31
32class TestCoreShell(unittest.TestCase):
33    """ Unit tests for coreshell model """
34   
35    def setUp(self):
36        from sans.models.CoreShellModel import CoreShellModel
37        self.comp = CoreShellModel()
38        #Give initial value to model
39        self.comp.setParam("scale", 1.0)
40        self.comp.setParam("radius", 60.0)
41        self.comp.setParam("thickness", 10.0)
42        self.comp.setParam("core_sld", 1.0e-6)
43        self.comp.setParam("shell_sld",2.0e-6)
44        self.comp.setParam("solvent_sld",3.0e-6)
45        self.comp.setParam("Background", 0.001)
46   
47        self.x = numpy.array([0.4, 1.3])
48        self.y = numpy.array([0.5, 1.57])
49        self.x_array = self.comp.evalDistribution(self.x)
50        self.y_array = self.comp.evalDistribution(self.y)
51       
52        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
53        qy_prime = numpy.reshape(self.y, [len(self.y),1])
54        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
55       
56    def test1D(self):
57        """ Test 1D model for a coreshell """
58        self.assertAlmostEquals(self.comp.run(0.4),0.00169, 4)
59       
60    def test1D_2(self):
61        """ Test 2D model for a coreshell """
62        self.assertAlmostEquals(self.comp.run([0.4, 1.3]),0.00169, 4)
63       
64    def testEval_1D(self):
65        """ Test 1D model for a coreshell  with evalDistribution"""
66        self.assertEquals(self.comp.run(0.4),self.x_array[0])
67        self.assertEquals(self.comp.run(1.3),self.x_array[1])
68       
69    def testEval_2D(self):
70        """ Test 2D model for a coreshell  with evalDistribution"""
71        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
72        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
73
74    # No more singular point   
75    #def testCriticalPoint(self):
76    #    """ Test coreshell at the critical point"""
77    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
78 
79class TestMultiShellModel(unittest.TestCase):
80    """ Unit tests for MultiShell Model """
81   
82    def setUp(self):
83        from sans.models.MultiShellModel import MultiShellModel
84        self.comp = MultiShellModel()
85        #Give initial value to model
86        self.comp.setParam("scale", 1.0)
87        self.comp.setParam("core_radius", 60.0)
88        self.comp.setParam("s_thickness", 10.0)
89        self.comp.setParam("w_thickness",10.0 )
90        self.comp.setParam("core_sld",6.4e-6)
91        self.comp.setParam("shell_sld",4e-7)
92        self.comp.setParam("n_pairs", 2)
93        self.comp.setParam("Background", 0.001)
94       
95        self.x = numpy.array([0.4, 1.3])
96        self.y = numpy.array([0.5, 1.57])
97        self.x_array = self.comp.evalDistribution(self.x)
98        self.y_array = self.comp.evalDistribution(self.y)
99        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
100        qy_prime = numpy.reshape(self.y, [len(self.y),1])
101        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
102       
103    def test1D(self):
104        """ Test 1D model for a MultiShell Model """
105        self.assertAlmostEquals(self.comp.run(0.001), 2442.81, 2)
106       
107    def test1D_2(self):
108        """ Test 2D model for a MultiShell Model"""
109        self.assertAlmostEquals(self.comp.run([0.001, 0.30903]), 2442.81, 2)
110     
111    def testEval_1D(self):
112        """ Test 1D model for a MultiShell  with evalDistribution"""
113        self.assertEquals(self.comp.run(0.4),self.x_array[0])
114        self.assertEquals(self.comp.run(1.3),self.x_array[1])
115       
116    def testEval_2D(self):
117        """ Test 2D model for a MultiShell  with evalDistribution"""
118        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
119        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
120
121    # No more singular point
122    #def testCriticalPoint(self):
123    #    """ Test multishell at the critical point"""
124    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
125   
126class TestVesicleModel(unittest.TestCase):
127    """ Unit tests for Vesicle Model """
128   
129    def setUp(self):
130        from sans.models.VesicleModel import VesicleModel
131        self.comp = VesicleModel()
132        #Give initial value to model
133        self.comp.setParam("scale", 1.0)
134        self.comp.setParam("radius", 100.0)
135        self.comp.setParam("core_sld", 6.36e-6)
136        self.comp.setParam("shell_sld",5e-7)
137        self.comp.setParam("thickness",30.0 )
138        self.comp.setParam("Background", 0.001)
139       
140        self.x = numpy.array([0.4, 1.3])
141        self.y = numpy.array([0.5, 1.57])
142        self.x_array = self.comp.evalDistribution(self.x)
143        self.y_array = self.comp.evalDistribution(self.y)
144        #qx_prime = numpy.reshape(self.x, [1,len(self.x)])
145        #qy_prime = numpy.reshape(self.y, [len(self.y),1])
146        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
147       
148    def test1D(self):
149        """ Test 1D model for a Vesicle Model """
150        self.assertAlmostEquals(self.comp.run(0.001), 1.71399e4,1)
151       
152    def test1D_2(self):
153        """ Test 2D model for a Vesicle Model"""
154        self.assertAlmostEquals(self.comp.run([0.001, 1.3]), 1.71399e4,1)
155       
156    def testEval_1D(self):
157        """ Test 1D model for a Vesicle with evalDistribution"""
158        self.assertEquals(self.comp.run(0.4),self.x_array[0])
159        self.assertEquals(self.comp.run(1.3),self.x_array[1])
160       
161    def testEval_2D(self):
162        """ Test 2D model for a Vesicle with evalDistribution"""
163        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
164        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
165
166   
167    def testCriticalPoint(self):
168        """ Test vesicle at the critical point"""
169        self.assert_(numpy.isfinite(self.comp.run(0.0))) 
170       
171       
172class TestBinaryHSModel(unittest.TestCase):
173    """ Unit tests for BinaryHS Model"""
174   
175    def setUp(self):
176        from sans.models.BinaryHSModel import BinaryHSModel
177        self.comp = BinaryHSModel()
178        #Give initial value to model
179        self.comp.setParam("l_radius", 100.0)
180        self.comp.setParam("ls_sld", 3.5e-6)
181        self.comp.setParam("s_radius",25)
182        self.comp.setParam("solvent_sld",6.36e-6 )
183        self.comp.setParam("ss_sld", 5e-7)
184        self.comp.setParam("vol_frac_ss", 0.1)
185        self.comp.setParam("vol_frac_ls", 0.2)
186        self.comp.setParam("Background", 0.001)
187       
188        self.x = numpy.array([0.4, 1.3])
189        self.y = numpy.array([0.5, 1.57])
190        self.x_array = self.comp.evalDistribution(self.x)
191        self.y_array = self.comp.evalDistribution(self.y)
192        #qx_prime = numpy.reshape(self.x, [1,len(self.x)])
193        #qy_prime = numpy.reshape(self.y, [len(self.y),1])
194        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
195       
196    def test1D(self):
197        """ Test 1D model for a BinaryHS Model"""
198        self.assertAlmostEquals(self.comp.run(0.001),60.6785, 4)
199       
200    def test1D_2(self):
201        """ Test 2D model for a BinaryHS Model"""
202        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),60.6785, 4)
203     
204    def testEval_1D(self):
205        """ Test 1D model for a BinaryHS with evalDistribution"""
206        self.assertEquals(self.comp.run(0.4),self.x_array[0])
207        self.assertEquals(self.comp.run(1.3),self.x_array[1])
208       
209    def testEval_2D(self):
210        """ Test 2D model for a BinaryHS with evalDistribution"""
211        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
212        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
213
214    # No more singular point   
215    #def testCriticalPoint(self):
216    #    """ Test BinaryHS at the critical point"""
217    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
218       
219     
220class TestCoreShellCylinderModel(unittest.TestCase):
221    """ Unit tests for CoreShellCylinder Model"""
222   
223    def setUp(self):
224        from sans.models.CoreShellCylinderModel import CoreShellCylinderModel
225        self.comp = CoreShellCylinderModel()
226        #Give initial value to model
227        self.comp.setParam("scale", 1.0)
228        self.comp.setParam("core_sld", 1e-6)
229        self.comp.setParam("length", 400)
230        self.comp.setParam("radius",20)
231        self.comp.setParam("solvent_sld",1e-6 )
232        self.comp.setParam("shell_sld", 4e-6)
233        self.comp.setParam("thickness", 10.0)
234        self.comp.setParam("Background", 0.01)
235       
236        self.x = numpy.array([0.4, 1.3])
237        self.y = numpy.array([0.5, 1.57])
238        self.x_array = self.comp.evalDistribution(self.x)
239        self.y_array = self.comp.evalDistribution(self.y)
240       
241        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
242        qy_prime = numpy.reshape(self.y, [len(self.y),1])
243        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
244       
245        self.q = 0.001
246        self.phi= math.pi/2
247        self.qx= self.q*math.cos(self.phi)
248        self.qy= self.q*math.sin(self.phi)
249       
250    def test1D(self):
251        """ Test 1D model for a CoreShellCylinder Model"""
252        self.assertAlmostEqual(self.comp.run(0.001), 353.56,1)
253       
254    def test1D_2(self):
255        """ Test 2D model for a CoreShellCylinder Model"""
256        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
257                              self.comp.runXY([self.qx, self.qy]),1)
258       
259    def testEval_1D(self):
260        """ Test 1D model for a CoreShellCylinder with evalDistribution"""
261        self.assertEquals(self.comp.run(0.4),self.x_array[0])
262        self.assertEquals(self.comp.run(1.3),self.x_array[1])
263       
264    def testEval_2D(self):
265        """ Test 2D model for a CoreShellCylinder with evalDistribution"""
266        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
267        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
268
269    # No more singular point
270    #def testCriticalPoint(self):
271    #    """ Test CoreShellCylinder at the critical point"""
272    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
273 
274 
275class TestHollowCylinderModel(unittest.TestCase):
276    """ Unit tests for HollowCylinder Model"""
277   
278    def setUp(self):
279        from sans.models.HollowCylinderModel import HollowCylinderModel
280        self.comp = HollowCylinderModel()
281        #Give initial value to model
282        self.comp.setParam("scale", 1.0)
283        self.comp.setParam("core_radius",20.0)
284        self.comp.setParam("radius",30)
285        self.comp.setParam("length", 400)
286        self.comp.setParam("sldCyl",6.3e-6 )
287        self.comp.setParam("sldSolv",1e-6 )
288        self.comp.setParam("Background", 0.01)
289       
290        self.x = numpy.array([0.4, 1.3])
291        self.y = numpy.array([0.5, 1.57])
292        self.x_array = self.comp.evalDistribution(self.x)
293        self.y_array = self.comp.evalDistribution(self.y)
294        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
295        qy_prime = numpy.reshape(self.y, [len(self.y),1])
296        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
297       
298        self.q = 0.001
299        self.phi= math.pi/2
300        self.qx= self.q*math.cos(self.phi)
301        self.qy= self.q*math.sin(self.phi)
302       
303    def test1D(self):
304        """ Test 1D model for a HollowCylinder Model"""
305        self.assertAlmostEqual(self.comp.run(0.001), 1756.76, 1)
306       
307    def test1D_2(self):
308        """ Test 2D model for a HollowCylinder Model"""
309        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
310                              self.comp.runXY([self.qx, self.qy]),1) 
311 
312    def testEval_1D(self):
313        """ Test 1D model for a HollowCylinder with evalDistribution"""
314        self.assertEquals(self.comp.run(0.4),self.x_array[0])
315        self.assertEquals(self.comp.run(1.3),self.x_array[1])
316       
317    def testEval_2D(self):
318        """ Test 2D model for a HollowCylinder with evalDistribution"""
319        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
320        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
321
322    # No more singular point   
323    #def testCriticalPoint(self):
324    #    """ Test HollowCylinder at the critical point"""
325    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
326       
327       
328class TestFlexibleCylinderModel(unittest.TestCase):
329    """ Unit tests for FlexibleCylinder Model"""
330   
331    def setUp(self):
332        from sans.models.FlexibleCylinderModel import FlexibleCylinderModel
333        self.comp = FlexibleCylinderModel()
334        #Give initial value to model
335        self.comp.setParam("scale", 1.0)
336        self.comp.setParam("sldSolv",6.3e-6 )
337        self.comp.setParam("sldCyl",1e-6 )
338        self.comp.setParam("kuhn_length",100)
339        self.comp.setParam("length", 1000)
340        self.comp.setParam("radius",20)
341        self.comp.setParam("Background", 0.0001)
342       
343        self.x = numpy.array([0.4, 1.3])
344        self.y = numpy.array([0.5, 1.57])
345        self.x_array = self.comp.evalDistribution(self.x)
346        self.y_array = self.comp.evalDistribution(self.y)
347       
348        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
349        qy_prime = numpy.reshape(self.y, [len(self.y),1])
350        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
351       
352        self.q = 0.001
353        self.phi= math.pi/2
354        self.qx= self.q*math.cos(self.phi)
355        self.qy= self.q*math.sin(self.phi)
356       
357    def test1D(self):
358        """ Test 1D model for a FlexibleCylinder Model"""
359        self.assertAlmostEqual(self.comp.run(0.001), 3509.22, 1)
360       
361    def test1D_2(self):
362        """ Test 2D model for a FlexibleCylinder Model"""
363        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
364                              self.comp.runXY([self.qx, self.qy]),1) 
365    def testEval_1D(self):
366        """ Test 1D model for a FlexibleCylinder Model with evalDistribution"""
367        self.assertEquals(self.comp.run(0.4),self.x_array[0])
368        self.assertEquals(self.comp.run(1.3),self.x_array[1])
369       
370    def testEval_2D(self):
371        """ Test 2D model for a FlexibleCylinder Model with evalDistribution"""
372        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
373        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
374
375    # No more singular point
376    #def testCriticalPoint(self):
377    #    """ Test FlexibleCylinder at the critical point"""
378    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
379 
380class TestFlexCylEllipXModel(unittest.TestCase):
381    """ Unit tests for FlexCylEllipXModel"""
382   
383    def setUp(self):
384        from sans.models.FlexCylEllipXModel import FlexCylEllipXModel
385        self.comp = FlexCylEllipXModel()
386        #Give initial value to model
387        self.comp.setParam("scale", 1.0)
388        self.comp.setParam("sldSolv",6.3e-6 )
389        self.comp.setParam("sldCyl",1e-6 )
390        self.comp.setParam("kuhn_length",100)
391        self.comp.setParam("length", 1000)
392        self.comp.setParam("radius",20)
393        self.comp.setParam("background", 0.0001)
394        self.comp.setParam("axis_ratio", 1.0)
395       
396        self.x = numpy.array([0.4, 1.3])
397        self.y = numpy.array([0.5, 1.57])
398        self.x_array = self.comp.evalDistribution(self.x)
399        self.y_array = self.comp.evalDistribution(self.y)
400       
401        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
402        qy_prime = numpy.reshape(self.y, [len(self.y),1])
403        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
404       
405        self.q = 0.001
406        self.phi= math.pi/2
407        self.qx= self.q*math.cos(self.phi)
408        self.qy= self.q*math.sin(self.phi)
409       
410    def test1D(self):
411        """ Test 1D model for FlexCylEllipXModel"""
412        self.assertAlmostEqual(self.comp.run(0.001), 3509.22, 1)
413       
414    def test1D_2(self):
415        """ Test 2D model for FlexCylEllipXModel"""
416        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
417                              self.comp.runXY([self.qx, self.qy]),1) 
418    def testEval_1D(self):
419        """ Test 1D model for FlexCylEllipXModel with evalDistribution"""
420        self.assertEquals(self.comp.run(0.4),self.x_array[0])
421        self.assertEquals(self.comp.run(1.3),self.x_array[1])
422       
423    def testEval_2D(self):
424        """ Test 2D model for FlexCylEllipXModel with evalDistribution"""
425        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
426        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
427             
428             
429class TestStackedDisksModel(unittest.TestCase):
430    """ Unit tests for StackedDisks Model"""
431   
432    def setUp(self):
433        from sans.models.StackedDisksModel import StackedDisksModel
434        self.comp = StackedDisksModel()
435        #Give initial value to model
436        self.comp.setParam("scale", 0.01 )
437        self.comp.setParam("radius",3000.0 )
438        self.comp.setParam("core_thick", 10.0)
439        self.comp.setParam("layer_thick",15.0 )
440        self.comp.setParam("core_sld",4e-006 )
441        self.comp.setParam("layer_sld",-4e-007 )
442        self.comp.setParam("solvent_sld", 5e-006 )
443        self.comp.setParam("n_stacking",1.0 )
444        self.comp.setParam("sigma_d", 0.0)
445        self.comp.setParam("background",0.001)
446        self.comp.setParam("axis_theta", 0.0 )
447        self.comp.setParam("axis_phi",0.0)
448       
449        self.x = numpy.array([0.4, 1.3])
450        self.y = numpy.array([0.5, 1.57])
451        self.x_array = self.comp.evalDistribution(self.x)
452        self.y_array = self.comp.evalDistribution(self.y)
453       
454        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
455        qy_prime = numpy.reshape(self.y, [len(self.y),1])
456        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
457       
458        self.q = 0.001
459        self.phi= math.pi/2
460        self.qx= self.q*math.cos(self.phi)
461        self.qy= self.q*math.sin(self.phi)
462       
463    def test1D(self):
464        """ Test 1D model for a StackedDisks Model"""
465        self.assertAlmostEqual(self.comp.run(0.001), 5075.12, 1)
466       
467    def test1D_2(self):
468        """ Test 2D model for a StackedDisks Model"""
469        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
470                              self.comp.runXY([self.qx, self.qy]),1)
471       
472    def testEval_1D(self):
473        """ Test 1D model for a StackedDisks Model with evalDistribution"""
474        self.assertEquals(self.comp.run(0.4),self.x_array[0])
475        self.assertEquals(self.comp.run(1.3),self.x_array[1])
476       
477    def testEval_2D(self):
478        """ Test 2D model for a StackedDisks Model with evalDistribution"""
479        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
480        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
481
482    # No more singular point
483    #def testCriticalPoint(self):
484    #    """ Test StackedDisks at the critical point"""
485    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
486   
487 
488class TestParallelepipedModel(unittest.TestCase):
489    """ Unit tests for Parallelepiped Model"""
490   
491    def setUp(self):
492        from sans.models.ParallelepipedModel import ParallelepipedModel
493        self.comp = ParallelepipedModel()
494        #Give initial value to model
495        self.comp.setParam("background", 0.0 )
496        self.comp.setParam("short_a",35)
497        self.comp.setParam("short_b", 75)
498        self.comp.setParam("long_c",400 )
499        self.comp.setParam("sldPipe", 6.3e-006 )
500        self.comp.setParam("sldSolv", 1e-006 )
501        self.comp.setParam("scale",1.0 )
502       
503        self.x = numpy.array([0.4, 1.3])
504        self.y = numpy.array([0.5, 1.57])
505        self.x_array = self.comp.evalDistribution(self.x)
506        self.y_array = self.comp.evalDistribution(self.y)
507       
508        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
509        qy_prime = numpy.reshape(self.y, [len(self.y),1])
510        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
511       
512        self.q = 0.001
513        self.phi= math.pi/2
514        self.qx= self.q*math.cos(self.phi)
515        self.qy= self.q*math.sin(self.phi)
516       
517   
518    def test1D(self):
519        """ Test 1D model for a Parallelepiped Model"""
520        self.assertAlmostEqual(self.comp.run(0.001), 2935.82, 2)
521       
522    def test1D_2(self):
523        """ Test 2D model for a Parallelepiped Model"""
524        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
525                              self.comp.runXY([self.qx, self.qy]),1)
526       
527    def testEval_1D(self):
528        """ Test 1D model for a Parallelepiped Model with evalDistribution"""
529        self.assertEquals(self.comp.run(0.4),self.x_array[0])
530        self.assertEquals(self.comp.run(1.3),self.x_array[1])
531       
532    def testEval_2D(self):
533        """ Test 2D model for a Parallelepiped Model with evalDistribution"""
534        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
535        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
536
537   
538    def testCriticalPoint(self):
539        """ Test Parallelepiped at the critical point"""
540        self.assert_(numpy.isfinite(self.comp.run(0.0)))
541 
542class TestEllipticalCylinderModel(unittest.TestCase):
543    """ Unit tests for EllipticalCylinder Model"""
544   
545    def setUp(self):
546        from sans.models.EllipticalCylinderModel import EllipticalCylinderModel
547        self.comp = EllipticalCylinderModel()
548        self.comp.setParam("scale",1.0) 
549        self.comp.setParam("r_minor",20.0)
550        self.comp.setParam("r_ratio",1.5) 
551        self.comp.setParam("length",400.0)
552        self.comp.setParam("sldCyl",4e-006)
553        self.comp.setParam("sldSolv",1e-006)
554        self.comp.setParam("background",0.0)
555        self.comp.setParam("cyl_theta",0.0)
556        self.comp.setParam("cyl_phi",0.0)
557        self.comp.setParam("cyl_psi",0.0)
558       
559        self.x = numpy.array([0.4, 1.3])
560        self.y = numpy.array([0.5, 1.57])
561        self.x_array = self.comp.evalDistribution(self.x)
562        self.y_array = self.comp.evalDistribution(self.y)
563       
564        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
565        qy_prime = numpy.reshape(self.y, [len(self.y),1])
566        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
567       
568        self.q = 0.001
569        self.phi= math.pi/2
570        self.qx= self.q*math.cos(self.phi)
571        self.qy= self.q*math.sin(self.phi)
572       
573    def test1D(self):
574        """ Test 1D model for a EllipticalCylinder Model"""
575        self.assertAlmostEqual(self.comp.run(0.001), 675.504402, 4)
576       
577    def test1D_2(self):
578        """ Test 2D model for a EllipticalCylinder Model"""
579        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
580                              self.comp.runXY([self.qx, self.qy]),1)
581       
582    def testEval_1D(self):
583        """ Test 1D model for a EllipticalCylinder with evalDistribution"""
584        self.assertEquals(self.comp.run(0.4),self.x_array[0])
585        self.assertEquals(self.comp.run(1.3),self.x_array[1])
586       
587    def testEval_2D(self):
588        """ Test 2D model for a EllipticalCylinder with evalDistribution"""
589        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
590        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
591
592   
593    def testCriticalPoint(self):
594        """ Test EllipticalCylinder at the critical point"""
595        self.assert_(numpy.isfinite(self.comp.run(0.0))) 
596 
597       
598class TestEllipsoidModel(unittest.TestCase):
599    """ Unit tests for Ellipsoid Model"""
600   
601    def setUp(self):
602        from sans.models.EllipsoidModel import EllipsoidModel
603        self.comp = EllipsoidModel()
604        self.comp.setParam("scale",1.0) 
605        self.comp.setParam("radius_a",20.0)
606        self.comp.setParam("radius_b",400.0)
607        self.comp.setParam("sldEll",4e-006)
608        self.comp.setParam("sldSolv",1e-006)
609        self.comp.setParam("background",0.0)
610        self.comp.setParam("axis_theta",1.57)
611        self.comp.setParam("axis_phi",0.0)
612       
613        self.x = numpy.array([0.4, 1.3])
614        self.y = numpy.array([0.5, 1.57])
615        self.x_array = self.comp.evalDistribution(self.x)
616        self.y_array = self.comp.evalDistribution(self.y)
617       
618        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
619        qy_prime = numpy.reshape(self.y, [len(self.y),1])
620        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
621       
622        self.q = 0.001
623        self.phi= math.pi/2
624        self.qx= self.q*math.cos(self.phi)
625        self.qy= self.q*math.sin(self.phi)
626       
627    def test1D(self):
628        """ Test 1D model for a Ellipsoid Model"""
629        self.assertAlmostEqual(self.comp.run(1.0), 0.000733968, 4)
630       
631    def test1D_2(self):
632        """ Test 2D model for a Ellipsoid Model"""
633        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
634                              self.comp.runXY([self.qx, self.qy]),1)
635    def testEval_1D(self):
636        """ Test 1D model for a Ellipsoid Model with evalDistribution"""
637        self.assertEquals(self.comp.run(0.4),self.x_array[0])
638        self.assertEquals(self.comp.run(1.3),self.x_array[1])
639       
640    def testEval_2D(self):
641        """ Test 2D model for a Ellipsoid Model with evalDistribution"""
642        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
643        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
644
645   
646    def testCriticalPoint(self):
647        """ Test Ellipsoid at the critical point"""
648        self.assert_(numpy.isfinite(self.comp.run(0.0)))
649       
650class TestCoreShellEllipsoidModel(unittest.TestCase):
651    """ Unit tests for CoreShellEllipsoid Model"""
652   
653    def setUp(self):
654        from sans.models.CoreShellEllipsoidModel import CoreShellEllipsoidModel
655        self.comp = CoreShellEllipsoidModel()
656        #Give initial value to model
657        self.comp.setParam("scale", 1.0)
658        self.comp.setParam("equat_core", 200.0)
659        self.comp.setParam("polar_core", 20.0)
660        self.comp.setParam("equat_shell",250.0)
661        self.comp.setParam("polar_shell", 30.0)
662        self.comp.setParam("sld_shell",1e-006)
663        self.comp.setParam("sld_core",2e-006)
664        self.comp.setParam("sld_solvent",6.3e-006)
665        self.comp.setParam("background",0.001)
666        self.comp.setParam("axis_theta", 0.0)
667        self.comp.setParam("axis_phi",0.0)
668         
669        self.x = numpy.array([0.4, 1.3])
670        self.y = numpy.array([0.5, 1.57])
671        self.x_array = self.comp.evalDistribution(self.x)
672        self.y_array = self.comp.evalDistribution(self.y)
673       
674        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
675        qy_prime = numpy.reshape(self.y, [len(self.y),1])
676        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
677       
678        self.q = 0.001
679        self.phi= math.pi/2
680        self.qx= self.q*math.cos(self.phi)
681        self.qy= self.q*math.sin(self.phi)
682       
683    def test1D(self):
684        """ Test 1D model for a CoreShellEllipsoid Model"""
685        self.assertAlmostEqual(self.comp.run(1.0), 0.001894, 4)
686       
687    def test1D_2(self):
688        """ Test 2D model for a CoreShellEllipsoid Model"""
689        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
690                              self.comp.runXY([self.qx, self.qy]),1)
691       
692    def testEval_1D(self):
693        """ Test 1D model for a CoreShellEllipsoid with evalDistribution"""
694        self.assertEquals(self.comp.run(0.4),self.x_array[0])
695        self.assertEquals(self.comp.run(1.3),self.x_array[1])
696       
697    def testEval_2D(self):
698        """ Test 2D model for a CoreShellEllipsoid with evalDistribution"""
699        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
700        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
701
702   
703    def testCriticalPoint(self):
704        """ Test CoreShellEllipsoid at the critical point"""
705        self.assert_(numpy.isfinite(self.comp.run(0.0)))
706   
707class TestTriaxialEllipsoidModel(unittest.TestCase):
708    """ Unit tests for TriaxialEllipsoid Model"""
709   
710    def setUp(self):
711        from sans.models.TriaxialEllipsoidModel import TriaxialEllipsoidModel
712        self.comp = TriaxialEllipsoidModel()
713        self.comp.setParam("scale",1.0)
714        self.comp.setParam("semi_axisA",35.0)
715        self.comp.setParam("semi_axisB", 100.0)
716        self.comp.setParam("semi_axisC",400.0 )
717        self.comp.setParam("sldSolv",6.3e-6)
718        self.comp.setParam("sldEll",1e-6)
719        self.comp.setParam("background",0.0)
720        self.comp.setParam("axis_theta", 1.0)
721        self.comp.setParam("axis_phi",0.0 )
722        self.comp.setParam("axis_psi",0.0 )
723       
724        self.x = numpy.array([0.4, 1.3])
725        self.y = numpy.array([0.5, 1.57])
726       
727        self.x_array = self.comp.evalDistribution(self.x)
728        self.y_array = self.comp.evalDistribution(self.y)
729        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
730        qy_prime = numpy.reshape(self.y, [len(self.y),1])
731        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
732       
733        self.q = 0.001
734        self.phi= math.pi/2
735        self.qx= self.q*math.cos(self.phi)
736        self.qy= self.q*math.sin(self.phi)
737       
738       
739    def test1D(self):
740        """ Test 1D model for a TriaxialEllipsoid Model"""
741        self.assertAlmostEquals(self.comp.run(0.001),16285.6, 1)
742       
743    def test1D_2(self):
744        """ Test 2D model for a TriaxialEllipsoid Model"""
745        self.assertAlmostEqual(self.comp.run([self.q, self.phi]), 
746                              self.comp.runXY([self.qx, self.qy]),1)
747     
748    def testEval_1D(self):
749        """ Test 1D model for a TriaxialEllipsoid Model with evalDistribution"""
750        self.assertEquals(self.comp.run(0.4),self.x_array[0])
751        self.assertEquals(self.comp.run(1.3),self.x_array[1])
752       
753    def testEval_2D(self):
754        """ Test 2D model for a TriaxialEllipsoid Model with evalDistribution"""
755        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
756        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
757
758   
759    def testCriticalPoint(self):
760        """ Test TriaxialEllipsoid at the critical point"""
761        self.assert_(numpy.isfinite(self.comp.run(0.0)))           
762   
763class TestLamellarModel(unittest.TestCase):
764    """ Unit tests for Lamellar Model"""
765   
766    def setUp(self):
767        from sans.models.LamellarModel import LamellarModel
768        self.comp = LamellarModel()
769        self.comp.setParam("scale",1.0) 
770        self.comp.setParam("bi_thick",50.0)
771        self.comp.setParam("sld_bi",1e-006)
772        self.comp.setParam("sld_sol",6.3e-006)
773        self.comp.setParam("background",0.0)
774
775        self.x = numpy.array([0.4, 1.3])
776        self.y = numpy.array([0.5, 1.57])
777       
778        self.x_array = self.comp.evalDistribution(self.x)
779        self.y_array = self.comp.evalDistribution(self.y)
780        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
781        qy_prime = numpy.reshape(self.y, [len(self.y),1])
782        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
783       
784    def test1D(self):
785        """ Test 1D model for a Lamellar Model"""
786        self.assertAlmostEquals(self.comp.run(0.001), 882289.54309, 3)
787       
788    def test1D_2(self):
789        """ Test 2D model for a Lamellar Model"""
790        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),882289.54309, 3)     
791   
792    def testEval_1D(self):
793        """ Test 1D model for a Lamellar Model with evalDistribution"""
794        self.assertEquals(self.comp.run(0.4),self.x_array[0])
795        self.assertEquals(self.comp.run(1.3),self.x_array[1])
796       
797    def testEval_2D(self):
798        """ Test 2D model for a Lamellar Model with evalDistribution"""
799        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
800        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
801       
802    # No more singular point
803    #def testCriticalPoint(self):
804    #    """ Test Lamellar at the critical point"""
805    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
806     
807class TestLamellarFFHGModel(unittest.TestCase):
808    """ Unit tests for LamellarFFHG Model"""
809   
810    def setUp(self):
811        from sans.models.LamellarFFHGModel import LamellarFFHGModel
812        self.comp = LamellarFFHGModel()
813        self.comp.setParam("scale",1.0) 
814        self.comp.setParam("t_length",15.0)
815        self.comp.setParam("h_thickness",10.0)
816        self.comp.setParam("sld_tail",4e-007)
817        self.comp.setParam("sld_head",3e-006)
818        self.comp.setParam("sld_solvent",6e-006)
819        self.comp.setParam("background",0.0)
820       
821        self.x = numpy.array([0.4, 1.3])
822        self.y = numpy.array([0.5, 1.57])
823       
824        self.x_array = self.comp.evalDistribution(self.x)
825        self.y_array = self.comp.evalDistribution(self.y)
826        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
827        qy_prime = numpy.reshape(self.y, [len(self.y),1])
828        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
829       
830       
831    def test1D(self):
832        """ Test 1D model for a LamellarFFHG Model"""
833        self.assertAlmostEquals(self.comp.run(0.001),653143.9209, 3)
834       
835    def test1D_2(self):
836        """ Test 2D model for a LamellarFFHG Model"""
837        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),653143.9209, 3)
838   
839    def testEval_1D(self):
840        """ Test 1D model for a LamellarFFHG Model with evalDistribution"""
841        self.assertEquals(self.comp.run(0.4),self.x_array[0])
842        self.assertEquals(self.comp.run(1.3),self.x_array[1])
843       
844    def testEval_2D(self):
845        """ Test 2D model for a LamellarFFHG Model with evalDistribution"""
846        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
847        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
848     
849    # No more singular point
850    #def testCriticalPoint(self):
851    #    """ Test LamellarFFHG at the critical point"""
852    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))             
853   
854class TestLamellarPSModel(unittest.TestCase):
855    """ Unit tests for LamellarPS Model"""
856   
857    def setUp(self):
858        from sans.models.LamellarPSModel import LamellarPSModel
859        self.comp = LamellarPSModel()
860        self.comp.setParam("scale",1.0) 
861        self.comp.setParam("spacing",400.0)
862        self.comp.setParam("delta",30.0)
863        self.comp.setParam("sld_bi",6.3e-006)
864        self.comp.setParam("sld_sol",1e-006)
865        self.comp.setParam("n_plates",20.0) 
866        self.comp.setParam("caille", 0.1)
867        self.comp.setParam("background",0.0)
868
869        self.x = numpy.array([0.4, 1.3])
870        self.y = numpy.array([0.5, 1.57])
871       
872        self.x_array = self.comp.evalDistribution(self.x)
873        self.y_array = self.comp.evalDistribution(self.y)
874        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
875        qy_prime = numpy.reshape(self.y, [len(self.y),1])
876        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
877       
878       
879    def test1D(self):
880        """ Test 1D model for a LamellarPS Model"""
881        self.assertAlmostEquals(self.comp.run(0.001), 27899.30836, 1)
882       
883    def test1D_2(self):
884        """ Test 2D model for a LamellarPS Model"""
885        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),27899.30836, 1) 
886   
887    def testEval_1D(self):
888        """ Test 1D model for a LamellarPS Model with evalDistribution"""
889        self.assertEquals(self.comp.run(0.4),self.x_array[0])
890        self.assertEquals(self.comp.run(1.3),self.x_array[1])
891       
892    def testEval_2D(self):
893        """ Test 2D model for a LamellarPS Model with evalDistribution"""
894        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
895        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
896     
897    # No more singular point       
898    #def testCriticalPoint(self):
899    #    """ Test LamellarPS at the critical point"""
900    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
901     
902class TestLamellarPSHGModel(unittest.TestCase):
903    """ Unit tests for LamellarPSHG Model"""
904   
905    def setUp(self):
906        from sans.models.LamellarPSHGModel import LamellarPSHGModel
907        self.comp = LamellarPSHGModel()
908        self.comp.setParam("scale",1.0)
909        self.comp.setParam("spacing",40.0)
910        self.comp.setParam("deltaT",10.0)
911        self.comp.setParam("deltaH",2.0)
912        self.comp.setParam("sld_tail",4e-7)
913        self.comp.setParam("sld_head",2e-6)
914        self.comp.setParam("sld_solvent",6e-6)
915        self.comp.setParam("n_plates",30)
916        self.comp.setParam("caille",0.001)
917        self.comp.setParam("background",0.001)
918
919        self.x = numpy.array([0.4, 1.3])
920        self.y = numpy.array([0.5, 1.57])
921       
922        self.x_array = self.comp.evalDistribution(self.x)
923        self.y_array = self.comp.evalDistribution(self.y)
924        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
925        qy_prime = numpy.reshape(self.y, [len(self.y),1])
926        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
927       
928    def test1D(self):
929        """ Test 1D model for a LamellarPSHG Model"""
930        self.assertAlmostEquals(self.comp.run(0.001),6831387.29466, 3)
931       
932    def test1D_2(self):
933        """ Test 2D model for a LamellarPSHG Model"""
934        self.assertAlmostEquals(self.comp.run([0.001, 1.3]),6831387.29466,3)
935       
936    def testEval_1D(self):
937        """ Test 1D model for a LamellarPSHG Model with evalDistribution"""
938        self.assertEquals(self.comp.run(0.4),self.x_array[0])
939        self.assertEquals(self.comp.run(1.3),self.x_array[1])
940       
941    def testEval_2D(self):
942        """ Test 2D model for a LamellarPSHG Model with evalDistribution"""
943        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
944        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
945       
946    # No more singular point
947    #def testCriticalPoint(self):
948    #    """ Test LamellarPSHG at the critical point"""
949    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
950     
951class TestSquareWellStructure(unittest.TestCase):
952    """ Unit tests for SquareWellStructure """
953   
954    def setUp(self):
955        from sans.models.SquareWellStructure import SquareWellStructure
956        self.comp = SquareWellStructure()
957        self.comp.setParam("effect_radius",50.0)
958        self.comp.setParam("volfraction",0.04)
959        self.comp.setParam("welldepth",1.5 )
960        self.comp.setParam("wellwidth",1.2)
961       
962        self.x = numpy.array([0.4, 1.3])
963        self.y = numpy.array([0.5, 1.57])
964       
965        self.x_array = self.comp.evalDistribution(self.x)
966        self.y_array = self.comp.evalDistribution(self.y)
967        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
968        qy_prime = numpy.reshape(self.y, [len(self.y),1])
969        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
970       
971       
972    def test1D(self):
973        """ Test 1D model for a SquareWellStructure"""
974        self.assertAlmostEqual(self.comp.run(0.001), 0.976657, 2)
975       
976    def test1D_2(self):
977        """ Test 2D model for a SquareWellStructure"""
978        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),0.9776657,2)     
979   
980    def testEval_1D(self):
981        """ Test 1D model for a SquareWellStructure with evalDistribution"""
982        self.assertEquals(self.comp.run(0.4),self.x_array[0])
983        self.assertEquals(self.comp.run(1.3),self.x_array[1])
984       
985    def testEval_2D(self):
986        """ Test 2D model for a SquareWellStructure with evalDistribution"""
987        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
988        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
989
990    # No more singular point
991    #def testCriticalPoint(self):
992    #    """ Test SquareWellStructure at the critical point"""
993    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))                     
994     
995class TestHardsphereStructure(unittest.TestCase):
996    """ Unit tests for HardsphereStructure"""
997   
998    def setUp(self):
999        from sans.models.HardsphereStructure import HardsphereStructure
1000        self.comp = HardsphereStructure()
1001        self.comp.setParam("effect_radius",50.0)
1002        self.comp.setParam("volfraction", 0.2)
1003        self.x = numpy.array([0.4, 1.3])
1004        self.y = numpy.array([0.5, 1.57])
1005       
1006        self.x_array = self.comp.evalDistribution(self.x)
1007        self.y_array = self.comp.evalDistribution(self.y)
1008        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1009        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1010        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1011       
1012       
1013    def test1D(self):
1014        """ Test 1D model for a HardsphereStructure"""
1015        self.assertAlmostEqual(self.comp.run(0.001),0.209128, 4)
1016       
1017    def test1D_2(self):
1018        """ Test 2D model for a HardsphereStructure"""
1019        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),0.209128, 4)
1020       
1021    def testEval_1D(self):
1022        """ Test 1D model for a HardsphereStructure with evalDistribution"""
1023        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1024        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1025       
1026    def testEval_2D(self):
1027        """ Test 2D model for a HardsphereStructure with evalDistribution"""
1028        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1029        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1030
1031    # No more singular point
1032    #def testCriticalPoint(self):
1033    #    """ Test HardsphereStructure at the critical point"""
1034    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))                 
1035   
1036class TestStickyHSStructure(unittest.TestCase):
1037    """ Unit tests for StickyHSStructure"""
1038   
1039    def setUp(self):
1040        from sans.models.StickyHSStructure import StickyHSStructure
1041        self.comp = StickyHSStructure()
1042        self.comp.setParam("effect_radius",50.0)
1043        self.comp.setParam("volfraction",0.1)
1044        self.comp.setParam("perturb",0.05)
1045        self.comp.setParam("stickiness",0.2)
1046
1047        self.x = numpy.array([0.4, 1.3])
1048        self.y = numpy.array([0.5, 1.57])
1049       
1050        self.x_array = self.comp.evalDistribution(self.x)
1051        self.y_array = self.comp.evalDistribution(self.y)
1052        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1053        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1054        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1055       
1056    def test1D(self):
1057        """ Test 1D model for a StickyHSStructure"""
1058        self.assertAlmostEqual(self.comp.run(0.001),1.09718, 4)
1059       
1060    def test1D_2(self):
1061        """ Test 2D model for a StickyHSStructure"""
1062        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),1.09718, 4)
1063       
1064    def testEval_1D(self):
1065        """ Test 1D model for a StickyHSStructure with evalDistribution"""
1066        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1067        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1068       
1069    def testEval_2D(self):
1070        """ Test 2D model for a StickyHSStructure with evalDistribution"""
1071        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1072        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1073
1074    # No more singular point           
1075    #def testCriticalPoint(self):
1076    #    """ Test StickyHSStructure at the critical point"""
1077    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
1078       
1079class TestHayterMSAStructure(unittest.TestCase):
1080    """ Unit tests for HayterMSAStructure"""
1081   
1082    def setUp(self):
1083        from sans.models.HayterMSAStructure import HayterMSAStructure
1084        self.comp = HayterMSAStructure()
1085        self.comp.setParam("effect_radius",20.75)
1086        self.comp.setParam("charge",19.0)
1087        self.comp.setParam("volfraction",0.0192 )
1088        self.comp.setParam("temperature",298)
1089        self.comp.setParam("saltconc",0.0)
1090        self.comp.setParam("dielectconst",78)
1091       
1092        self.x = numpy.array([0.4, 1.3])
1093        self.y = numpy.array([0.5, 1.57])
1094       
1095        self.x_array = self.comp.evalDistribution(self.x)
1096        self.y_array = self.comp.evalDistribution(self.y)
1097        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1098        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1099        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1100
1101    def test1D(self):
1102        """ Test 1D model for a HayterMSAStructure"""
1103        self.assertAlmostEqual(self.comp.run(0.001),0.0712928, 4)
1104       
1105    def test1D_2(self):
1106        """ Test 2D model for a HayterMSAStructure"""
1107        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),0.0712928, 4) 
1108       
1109    def testEval_1D(self):
1110        """ Test 1D model for a HayterMSAStructure with evalDistribution"""
1111        self.assertTrue(math.fabs(self.comp.run(0.4)-self.x_array[0])<0.025, "Difference too big: %g" % math.fabs(self.comp.run(0.4)-self.x_array[0]))
1112        self.assertTrue(math.fabs(self.comp.run(1.3)-self.x_array[1])<0.025, "Difference too big: %g" % math.fabs(self.comp.run(1.3)-self.x_array[1]))
1113       
1114    def testEval_2D(self):
1115        """ Test 2D model for a HayterMSAStructure with evalDistribution"""
1116        self.assertTrue(math.fabs(self.comp.runXY([0.4, 0.5])-self.xy_matrix[0])<0.05, "Difference too big: %g" % math.fabs(self.comp.runXY([0.4, 0.5])-self.xy_matrix[0]))
1117        self.assertTrue(math.fabs(self.comp.runXY([1.3,1.57])-self.xy_matrix[1])<0.05, "Difference too big: %g" % math.fabs(self.comp.runXY([1.3,1.57])-self.xy_matrix[1]))
1118
1119   
1120    def testCriticalPoint(self):
1121        """ Test HayterMSAStructure at the critical point"""
1122        self.assert_(numpy.isfinite(self.comp.run(0.0)))                   
1123     
1124     
1125class TestBEPolyelectrolyte(unittest.TestCase):
1126    """ Unit tests for BEPolyelectrolyte"""
1127   
1128    def setUp(self):
1129        from sans.models.BEPolyelectrolyte import BEPolyelectrolyte
1130        self.comp = BEPolyelectrolyte()
1131       
1132        self.comp.setParam('k',10)
1133        self.comp.setParam('lb',7.1)
1134        self.comp.setParam('h',12)
1135        self.comp.setParam('b',10)
1136        self.comp.setParam('cs', 0.0)
1137        self.comp.setParam('alpha',0.05)
1138        self.comp.setParam('c', 0.7)
1139        self.comp.setParam('background',0.001)
1140         
1141        self.x = numpy.array([0.4, 1.3])
1142        self.y = numpy.array([0.5, 1.57])
1143       
1144        self.x_array = self.comp.evalDistribution(self.x)
1145        self.y_array = self.comp.evalDistribution(self.y)
1146        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1147        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1148        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1149
1150    def test1D(self):
1151        """ Test 1D model for a BEPolyelectrolyte"""
1152        self.assertAlmostEqual(self.comp.run(0.001),0.0948, 3)
1153       
1154    def test1D_2(self):
1155        """ Test 2D model for a BEPolyelectrolyte"""
1156        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),0.0948, 3)
1157     
1158    def testEval_1D(self):
1159        """ Test 1D model for a BEPolyelectrolyte with evalDistribution"""
1160        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1161        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1162       
1163    def testEval_2D(self):
1164        """ Test 2D model for a BEPolyelectrolyte with evalDistribution"""
1165        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1166        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1167
1168   
1169    def testCriticalPoint(self):
1170        """ Test BEPolyelectrolyte at the critical point"""
1171        self.assert_(numpy.isfinite(self.comp.run(0.0)))           
1172             
1173             
1174class TestDABModel(unittest.TestCase):
1175    """ Unit tests for DABModel"""
1176   
1177    def setUp(self):
1178        from sans.models.DABModel import DABModel
1179        self.comp = DABModel()
1180        self.comp.setParam('length',40.0)
1181        self.comp.setParam('scale',10.0)
1182        self.comp.setParam('background',1.0)
1183       
1184        self.x = numpy.array([0.4, 1.3])
1185        self.y = numpy.array([0.5, 1.57])
1186   
1187        self.x_array = self.comp.evalDistribution(self.x)
1188        self.y_array = self.comp.evalDistribution(self.y)
1189        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1190        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1191        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1192       
1193    def test1D(self):
1194        """ Test 1D model for a DABModel"""
1195        self.assertAlmostEqual(self.comp.run(0.001),637957.9047, 3)
1196       
1197    def test1D_2(self):
1198        """ Test 2D model for a DABModel"""
1199        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),637957.90473, 3)
1200         
1201    def testEval_1D(self):
1202        """ Test 1D model for a DABModel with evalDistribution"""
1203        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1204        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1205       
1206    def testEval_2D(self):
1207        """ Test 2D model for a DABModel with evalDistribution"""
1208        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1209        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1210
1211   
1212    def testCriticalPoint(self):
1213        """ Test DABModel at the critical point"""
1214        self.assert_(numpy.isfinite(self.comp.run(0.0)))           
1215             
1216   
1217class TestGuinierModel(unittest.TestCase):
1218    """ Unit tests for Guinier Model"""
1219   
1220    def setUp(self):
1221        from sans.models.GuinierModel import GuinierModel
1222        self.comp = GuinierModel()
1223        self.comp.setParam('scale',1.0)
1224        self.comp.setParam('rg', 1)
1225       
1226        self.x = numpy.array([0.4, 1.3])
1227        self.y = numpy.array([0.5, 1.57])
1228       
1229        self.x_array = self.comp.evalDistribution(self.x)
1230        self.y_array = self.comp.evalDistribution(self.y)
1231        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1232        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1233        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1234       
1235    def test1D(self):
1236        """ Test 1D model for a GuinierModel"""
1237        self.assertAlmostEqual(self.comp.run(1.0),0.716531, 4)
1238       
1239    def test1D_2(self):
1240        """ Test 2D model for a GuinierModel"""
1241        self.assertAlmostEqual(self.comp.run([1.0, 1.3]),0.716531, 4)
1242     
1243    def testEval_1D(self):
1244        """ Test 1D model for a GuinierModel with evalDistribution"""
1245        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1246        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1247       
1248    def testEval_2D(self):
1249        """ Test 2D model for a GuinierModel with evalDistribution"""
1250        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1251        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1252
1253   
1254    def testCriticalPoint(self):
1255        """ Test GuinierModel at the critical point"""
1256        self.assert_(numpy.isfinite(self.comp.run(0.0)))
1257       
1258       
1259class TestDebyeModel(unittest.TestCase):
1260    """ Unit tests for Debye Model"""
1261   
1262    def setUp(self):
1263        from sans.models.DebyeModel import DebyeModel
1264        self.comp = DebyeModel()
1265        self.comp.setParam('rg', 50.0)
1266        self.comp.setParam('scale',1.0)
1267        self.comp.setParam('background',0.001)
1268       
1269        self.x = numpy.array([0.4, 1.3])
1270        self.y = numpy.array([0.5, 1.57])
1271       
1272        self.x_array = self.comp.evalDistribution(self.x)
1273        self.y_array = self.comp.evalDistribution(self.y)
1274        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1275        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1276        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1277       
1278    def test1D(self):
1279        """ Test 1D model for a DebyeModel"""
1280        self.assertAlmostEqual(self.comp.run(0.001),1.00017,4)
1281       
1282    def test1D_2(self):
1283        """ Test 2D model for a DebyeModel"""
1284        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),1.00017,4)
1285       
1286    def testEval_1D(self):
1287        """ Test 1D model for a DebyeModel with evalDistribution"""
1288        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1289        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1290       
1291    def testEval_2D(self):
1292        """ Test 2D model for a DebyeModel with evalDistribution"""
1293        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1294        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1295
1296   
1297    def testCriticalPoint(self):
1298        """ Test DebyeModel at the critical point"""
1299        self.assertEquals(self.comp.run(0.0),1.001)
1300       
1301       
1302class TestPorodModel(unittest.TestCase):
1303    """ Unit tests for PorodModel"""
1304   
1305    def setUp(self):
1306        from sans.models.PorodModel import PorodModel
1307        self.comp = PorodModel()
1308        self.comp.setParam('scale', 1.0)
1309        self.comp.setParam('background', 0.0)
1310         
1311        self.x = numpy.array([0.4, 1.3])
1312        self.y = numpy.array([0.5, 1.57])
1313       
1314        self.x_array = self.comp.evalDistribution(self.x)
1315        self.y_array = self.comp.evalDistribution(self.y)
1316        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1317        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1318        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1319       
1320    def test1D(self):
1321        """ Test 1D model for a PorodModel"""
1322        self.assertEquals(self.comp.run(0.5), 16)
1323       
1324    def test1D_2(self):
1325        """ Test 2D model for a PorodModel"""
1326        self.assertEquals(self.comp.run([0.5, 1.3]),16) 
1327       
1328    def testEval_1D(self):
1329        """ Test 1D model for a PorodModel with evalDistribution"""
1330        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1331        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1332       
1333    def testEval_2D(self):
1334        """ Test 2D model for a PorodModel with evalDistribution"""
1335        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1336        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1337
1338   
1339    def testCreaticalPoint(self):
1340        """ Test for critical point for PorodModel run"""
1341        self.assertRaises(ZeroDivisionError, self.comp.run, 0.0)
1342       
1343       
1344class TestPeakGaussModel(unittest.TestCase):
1345    """ Unit tests for PeakGaussModel"""
1346   
1347    def setUp(self):
1348        from sans.models.PeakGaussModel import PeakGaussModel
1349        self.comp = PeakGaussModel()
1350        self.comp.setParam('scale', 100)
1351        self.comp.setParam('B', 0.005)
1352        self.comp.setParam('q0',0.05)
1353        self.comp.setParam('background',1.0)
1354       
1355        self.x = numpy.array([0.4, 1.3])
1356        self.y = numpy.array([0.5, 1.57])
1357       
1358        self.x_array = self.comp.evalDistribution(self.x)
1359        self.y_array = self.comp.evalDistribution(self.y)
1360        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1361        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1362        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1363       
1364    def test1D(self):
1365        """ Test 1D model for a PeakGauss Model"""
1366        self.assertEquals(self.comp.run(0.001),1)
1367       
1368    def test1D_2(self):
1369        """ Test 2D model for a PeakGauss Model"""
1370        self.assertEquals(self.comp.run([0.001, 1.3]),1) 
1371       
1372    def testEval_1D(self):
1373        """ Test 1D model for a PeakGauss Model with evalDistribution"""
1374        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1375        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1376       
1377    def testEval_2D(self):
1378        """ Test 2D model for a PeakGauss Model with evalDistribution"""
1379        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1380        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1381   
1382    def testCriticalPoint(self):
1383        """ Test PeakGauss at the critical point"""
1384        self.assert_(numpy.isfinite(self.comp.run(0.0)))   
1385       
1386class TestPeakLorentzModel(unittest.TestCase):
1387    """ Unit tests for PeakLorentzModel"""
1388   
1389    def setUp(self):
1390        from sans.models.PeakLorentzModel import PeakLorentzModel
1391        self.comp = PeakLorentzModel()
1392        self.comp.setParam('scale', 100)
1393        self.comp.setParam('B', 0.005)
1394        self.comp.setParam('q0',0.05)
1395        self.comp.setParam('background',1.0)
1396       
1397        self.x = numpy.array([0.4, 1.3])
1398        self.y = numpy.array([0.5, 1.57])
1399       
1400        self.x_array = self.comp.evalDistribution(self.x)
1401        self.y_array = self.comp.evalDistribution(self.y)
1402        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1403        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1404        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1405       
1406    def test1D(self):
1407        """ Test 1D model for a PeakLorentz Model"""
1408        self.assertAlmostEqual(self.comp.run(0.001), 2.0305, 3)
1409       
1410    def test1D_2(self):
1411        """ Test 2D model for a PeakLorentz Model"""
1412        self.assertAlmostEqual(self.comp.run([0.001, 1.3]), 2.0305, 3)
1413       
1414    def testEval_1D(self):
1415        """ Test 1D model for a PeakLorentz Model with evalDistribution"""
1416        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1417        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1418       
1419    def testEval_2D(self):
1420        """ Test 2D model for a PeakLorentz Model with evalDistribution"""
1421        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1422        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1423
1424       
1425    def testCriticalPoint(self):
1426        """ Test PeakLorentz at the critical point"""
1427        self.comp.setParam('B', 0.0)
1428        self.assertRaises(ZeroDivisionError, self.comp.run, 10)
1429        #self.assert_(numpy.isfinite(self.comp.run(0.0))) 
1430       
1431       
1432class TestFractalAbsModel(unittest.TestCase):
1433    """ Unit tests for FractalAbsModel"""
1434   
1435    def setUp(self):
1436        from sans.models.FractalAbsModel import FractalAbsModel
1437        self.comp = FractalAbsModel()
1438        self.comp.setParam('scale', 0.05)
1439        self.comp.setParam('radius', 5.0)
1440        self.comp.setParam('fractal_dim', 2.0)
1441        self.comp.setParam('cor_length',100.0)
1442        self.comp.setParam('sldBlock', 2.0e-6)
1443        self.comp.setParam('sldSolv', 6.35e-6)
1444        self.comp.setParam('background',0.0)
1445       
1446        self.x = numpy.array([0.4, 1.3])
1447        self.y = numpy.array([0.5, 1.57])
1448       
1449        self.x_array = self.comp.evalDistribution(self.x)
1450        self.y_array = self.comp.evalDistribution(self.y)
1451        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1452        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1453        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1454       
1455    def test1D(self):
1456        """ Test 1D model for a Fractal Abs Model"""
1457        self.assertAlmostEqual(self.comp.run(0.001), 39.2881, 3)
1458       
1459    def test1D_2(self):
1460        """ Test 2D model for a Fractal Abs Model"""
1461        self.assertAlmostEqual(self.comp.run([0.001, 1.3]), 39.2881, 3)
1462       
1463    def testEval_1D(self):
1464        """ Test 1D model for a Fractal Abs Model with evalDistribution"""
1465        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1466        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1467       
1468    def testEval_2D(self):
1469        """ Test 2D model for a Fractal Abs Model with evalDistribution"""
1470        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1471        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1472
1473    # No more singular point
1474    #def testCriticalPoint(self):
1475    #    """ Test Fractal Abs at the critical point"""
1476    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))   
1477   
1478class TestFractalModel(unittest.TestCase):
1479    """ Unit tests for FractalModel"""
1480   
1481    def setUp(self):
1482        from sans.models.FractalModel import FractalModel
1483        self.comp = FractalModel()
1484        self.comp.setParam('scale', 0.05)
1485        self.comp.setParam('radius', 5.0)
1486        self.comp.setParam('fractal_dim', 2.0)
1487        self.comp.setParam('cor_length',100.0)
1488        self.comp.setParam('sldBlock', 2.0e-6)
1489        self.comp.setParam('sldSolv', 6.35e-6)
1490        self.comp.setParam('background',0.0)
1491       
1492        self.x = numpy.array([0.4, 1.3])
1493        self.y = numpy.array([0.5, 1.57])
1494       
1495        self.x_array = self.comp.evalDistribution(self.x)
1496        self.y_array = self.comp.evalDistribution(self.y)
1497        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1498        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1499        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1500       
1501    def test1D(self):
1502        """ Test 1D model for a Fractal Model"""
1503        self.assertAlmostEqual(self.comp.run(0.001), 39.2881, 3)
1504       
1505    def test1D_2(self):
1506        """ Test 2D model for a Fractal Model"""
1507        self.assertAlmostEqual(self.comp.run([0.001, 1.3]), 39.2881, 3)
1508       
1509    def testEval_1D(self):
1510        """ Test 1D model for a Fractal Model with evalDistribution"""
1511        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1512        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1513       
1514    def testEval_2D(self):
1515        """ Test 2D model for a Fractal Model with evalDistribution"""
1516        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1517        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1518
1519    # No more singular point   
1520    #def testCriticalPoint(self):
1521    #    """ Test Fractal at the critical point"""
1522    #    self.assert_(numpy.isfinite(self.comp.run(0.0)))
1523   
1524class TestLorentzModel(unittest.TestCase):
1525    """ Unit tests for LorentzModel"""
1526   
1527    def setUp(self):
1528        from sans.models.LorentzModel import LorentzModel
1529        self.comp = LorentzModel()
1530        self.comp.setParam("background",1)
1531        self.comp.setParam("length",50)
1532        self.comp.setParam("scale",100)
1533       
1534        self.x = numpy.array([0.4, 1.3])
1535        self.y = numpy.array([0.5, 1.57])
1536       
1537        self.x_array = self.comp.evalDistribution(self.x)
1538        self.y_array = self.comp.evalDistribution(self.y)
1539        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1540        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1541        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1542       
1543    def test1D(self):
1544        """ Test 1D model for a Lorentz Model"""
1545        self.assertAlmostEqual(self.comp.run(0.001),100.751, 2)
1546       
1547    def test1D_2(self):
1548        """ Test 2D model for a Lorentz Model"""
1549        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),100.751, 2)
1550   
1551    def testEval_1D(self):
1552        """ Test 1D model for a Lorentz Model with evalDistribution"""
1553        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1554        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1555       
1556    def testEval_2D(self):
1557        """ Test 2D model for a Lorentz Model with evalDistribution"""
1558        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1559        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1560
1561         
1562    def testCriticalPoint(self):
1563        """ Test Lorentz at the critical point"""
1564        self.assert_(numpy.isfinite(self.comp.run(0.0)))
1565       
1566         
1567class TestPowerLawAbsModel(unittest.TestCase):
1568    """ Unit tests for PowerLawAbsModel"""
1569   
1570    def setUp(self):
1571        from sans.models.PowerLawAbsModel import PowerLawAbsModel
1572        self.comp = PowerLawAbsModel()
1573        self.comp.setParam("background",1)
1574        self.comp.setParam("m",4)
1575        self.comp.setParam("scale",1e-6)
1576       
1577        self.x = numpy.array([0.4, 1.3])
1578        self.y = numpy.array([0.5, 1.57])
1579        self.x_array = self.comp.evalDistribution(self.x)
1580        self.y_array = self.comp.evalDistribution(self.y)
1581        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1582        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1583        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1584       
1585    def test1D(self):
1586        """ Test 1D model for a PowerLawAbs Model"""
1587        self.assertAlmostEqual(self.comp.run(0.19189), 1.00074,4)
1588       
1589    def test1D_2(self):
1590        """ Test 2D model for a PowerLawAbs Model"""
1591        self.assertAlmostEqual(self.comp.run([0.19189,1.3]), 1.00074,4)
1592       
1593    def testEval_1D(self):
1594        """ Test 1D model for a PowerLawAbs Model with evalDistribution"""
1595        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1596        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1597       
1598    def testEval_2D(self):
1599        """ Test 2D model for a PowerLawAbs Model with evalDistribution"""
1600        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1601        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1602
1603   
1604    def testCriticalPoint(self):
1605        """ Test PowerLawAbs at the critical point"""
1606        self.assert_(numpy.isfinite(self.comp.run(0.0)))
1607       
1608       
1609class TestPowerLawModel(unittest.TestCase):
1610    """ Unit tests for PowerLawModel"""
1611   
1612    def setUp(self):
1613        from sans.models.PowerLawModel import PowerLawModel
1614        self.comp = PowerLawModel()
1615        self.comp.setParam("background",1)
1616        self.comp.setParam("m",4)
1617        self.comp.setParam("scale",1e-6)
1618       
1619        self.x = numpy.array([0.4, 1.3])
1620        self.y = numpy.array([0.5, 1.57])
1621        self.x_array = self.comp.evalDistribution(self.x)
1622        self.y_array = self.comp.evalDistribution(self.y)
1623        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1624        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1625        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1626       
1627    def test1D(self):
1628        """ Test 1D model for a PowerLaw Model"""
1629        self.assertAlmostEquals(self.comp.run(0.19189), 1.00074,4)
1630       
1631    def test1D_2(self):
1632        """ Test 2D model for a PowerLawModel"""
1633        self.assertAlmostEquals(self.comp.run([0.19189,1.3]), 1.00074,4)
1634       
1635    def testEval_1D(self):
1636        """ Test 1D model for a PowerLawModel with evalDistribution"""
1637        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1638        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1639       
1640    def testEval_2D(self):
1641        """ Test 2D model for a PowerLawModel with evalDistribution"""
1642        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1643        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1644
1645   
1646    def testCriticalPoint(self):
1647        """ Test PowerLawModel at the critical point"""
1648        self.assert_(numpy.isfinite(self.comp.run(0.0)))
1649     
1650     
1651class TestTeubnerStreyModel(unittest.TestCase):
1652    """ Unit tests for TeubnerStreyModel"""
1653   
1654    def setUp(self):
1655        from sans.models.TeubnerStreyModel import TeubnerStreyModel
1656        self.comp = TeubnerStreyModel()
1657        self.comp.setParam("background",0.1)
1658        self.comp.setParam("c1",-30)
1659        self.comp.setParam("c2",5000)
1660        self.comp.setParam("scale",0.1)
1661       
1662        self.x = numpy.array([0.4, 1.3])
1663        self.y = numpy.array([0.5, 1.57])
1664        self.x_array = self.comp.evalDistribution(self.x)
1665        self.y_array = self.comp.evalDistribution(self.y)
1666        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1667        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1668        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1669       
1670    def test1D(self):
1671        """ Test 1D model for a TeubnerStrey Model"""
1672        self.assertAlmostEqual(self.comp.run(0.001),10.103, 1)
1673       
1674    def test1D_2(self):
1675        """ Test 2D model for a TeubnerStrey Model"""
1676        self.assertAlmostEqual(self.comp.run([0.001, 1.3]),10.103, 1)
1677       
1678    def testEval_1D(self):
1679        """ Test 1D model for a TeubnerStrey  with evalDistribution"""
1680        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1681        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1682       
1683    def testEval_2D(self):
1684        """ Test 2D model for a TeubnerStrey  with evalDistribution"""
1685        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0],8)
1686        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1687
1688   
1689    def testCriticalPoint(self):
1690        """ Test TeubnerStrey at the critical point"""
1691        self.assert_(numpy.isfinite(self.comp.run(0.0)))   
1692     
1693     
1694class TestLineModel(unittest.TestCase):
1695    """ Unit tests for LineModel"""
1696   
1697    def setUp(self):
1698        from sans.models.LineModel import LineModel
1699        self.comp = LineModel()
1700        self.comp.setParam("A",1)
1701        self.comp.setParam("B",1)
1702       
1703        self.x = numpy.array([0.4, 1.3])
1704        self.y = numpy.array([0.5, 1.57])
1705        self.x_array = self.comp.evalDistribution(self.x)
1706        self.y_array = self.comp.evalDistribution(self.y)
1707        qx_prime = numpy.reshape(self.x, [1,len(self.x)])
1708        qy_prime = numpy.reshape(self.y, [len(self.y),1])
1709        self.xy_matrix = self.comp.evalDistribution([self.x, self.y])
1710       
1711    def test1D(self):
1712        """ Test 1D model for a Line Model"""
1713        self.assertEquals(self.comp.run(1.0),2)
1714       
1715    def testEval_1D(self):
1716        """ Test 1D model for a Line  with evalDistribution"""
1717        self.assertEquals(self.comp.run(0.4),self.x_array[0])
1718        self.assertEquals(self.comp.run(1.3),self.x_array[1])
1719       
1720    def testEval_2D(self):
1721        """ Test 2D model for a Line  with evalDistribution"""
1722        self.assertAlmostEquals(self.comp.runXY([0.4, 0.5]),self.xy_matrix[0], 8)
1723        self.assertAlmostEquals(self.comp.runXY([1.3,1.57]),self.xy_matrix[1], 8)
1724
1725   
1726    def testCriticalPoint(self):
1727        """ Test line at the critical point"""
1728        self.assert_(numpy.isfinite(self.comp.run(0.0)))
1729 
1730if __name__ == '__main__':
1731    unittest.main()
Note: See TracBrowser for help on using the repository browser.