source: sasview/sansmodels/src/sans/models/test/utest_dispersity.py @ ae60f86

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 ae60f86 was ae60f86, checked in by Mathieu Doucet <doucetm@…>, 16 years ago

changing base model
  • Property mode set to 100644
File size: 17.2 KB
Line 
1"""
2    Unit tests for dispersion functionality of
3    C++ model classes
4"""
5
6import unittest, math, numpy
7
8class TestCylinder(unittest.TestCase):
9    """
10        Testing C++ Cylinder model
11    """
12    def setUp(self):
13        from sans.models.CylinderModel import CylinderModel
14        self.model= CylinderModel()
15       
16        self.model.setParam('scale', 1.0)
17        self.model.setParam('radius', 20.0)
18        self.model.setParam('length', 400.0)
19        self.model.setParam('contrast', 3.e-6)
20        self.model.setParam('background', 0.0)
21        self.model.setParam('cyl_theta', 0.0)
22        self.model.setParam('cyl_phi', 0.0)
23       
24    def test_simple(self):
25        self.assertAlmostEqual(self.model.run(0.001), 450.355, 3)
26        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 452.299, 3)
27       
28    def test_constant(self):
29        from sans.models.dispersion_models import DispersionModel
30        disp = DispersionModel()
31        self.model.setParam('scale', 10.0)
32        self.model.set_dispersion('radius', disp)
33        self.model.dispersion['radius']['width'] = 5.0
34        self.model.dispersion['radius']['npts'] = 100
35       
36        self.assertAlmostEqual(self.model.run(0.001), 4527.47250339, 3)
37        self.assertAlmostEqual(self.model.runXY([0.001, 0.001]), 4546.997777604715, 3)
38       
39    def test_gaussian(self):
40        from sans.models.dispersion_models import GaussianDispersion
41        disp = GaussianDispersion()
42        self.model.set_dispersion('radius', disp)
43        self.model.dispersion['radius']['width'] = 5.0
44        self.model.dispersion['radius']['npts'] = 100
45        self.model.setParam('scale', 10.0)
46       
47        self.assertAlmostEqual(self.model.run(0.001), 4723.32213339, 3)
48        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 4743.56, 2)
49       
50    def test_gaussian_zero(self):
51        from sans.models.dispersion_models import GaussianDispersion
52        disp = GaussianDispersion()
53        self.model.set_dispersion('radius', disp)
54        self.model.dispersion['radius']['width'] = 0.0
55        self.model.dispersion['radius']['npts'] = 100
56        self.model.setParam('scale', 1.0)
57       
58        self.assertAlmostEqual(self.model.run(0.001), 450.355, 3)
59        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 452.299, 3)
60       
61    def test_array(self):
62        """
63            Perform complete rotational average and
64            compare to 1D
65        """
66        from sans.models.dispersion_models import ArrayDispersion
67        disp_ph = ArrayDispersion()
68        disp_th = ArrayDispersion()
69       
70        values_ph = numpy.zeros(100)
71        values_th = numpy.zeros(100)
72        weights   = numpy.zeros(100)
73        for i in range(100):
74            values_ph[i]=(2.0*math.pi/99.0*i)
75            values_th[i]=(math.pi/99.0*i)
76            weights[i]=(1.0)
77       
78        disp_ph.set_weights(values_ph, weights)
79        disp_th.set_weights(values_th, weights)
80       
81        self.model.set_dispersion('cyl_theta', disp_th)
82        self.model.set_dispersion('cyl_phi', disp_ph)
83       
84        val_1d = self.model.run(math.sqrt(0.0002))
85        val_2d = self.model.runXY([0.01,0.01]) 
86       
87        self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
88       
89class TestCoreShellCylinder(unittest.TestCase):
90    """
91        Testing C++ Cylinder model
92    """
93    def setUp(self):
94        from sans.models.CoreShellCylinderModel import CoreShellCylinderModel
95        self.model= CoreShellCylinderModel()
96       
97        self.model.setParam('scale', 1.0)
98        self.model.setParam('radius', 20.0)
99        self.model.setParam('thickness', 10.0)
100        self.model.setParam('length', 400.0)
101        self.model.setParam('core_sld', 1.e-6)
102        self.model.setParam('shell_sld', 4.e-6)
103        self.model.setParam('solvent_sld', 1.e-6)
104        self.model.setParam('background', 0.0)
105        self.model.setParam('axis_theta', 0.0)
106        self.model.setParam('axis_phi', 0.0)
107       
108    def test_simple(self):
109        """
110            Test simple 1D and 2D values
111            Numbers taken from model that passed validation, before
112            the update to C++ underlying class.
113        """
114        self.assertAlmostEqual(self.model.run(0.001), 353.55013216754583, 3)
115        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 355.25355270620543, 3)
116       
117    def test_dispersion(self):
118        """
119            Test with dispersion
120        """
121        from sans.models.DisperseModel import DisperseModel
122        disp = DisperseModel(self.model, ['radius', 'thickness', 'length'], [5, 2, 50])
123        disp.setParam('n_pts', 10)
124        self.assertAlmostEqual(disp.run(0.001), 358.44062724936009, 3)
125        self.assertAlmostEqual(disp.runXY([0.001,0.001]), 360.22673635224584, 3)
126
127    def test_new_disp(self):
128        from sans.models.dispersion_models import GaussianDispersion
129        disp_rm = GaussianDispersion()
130        self.model.set_dispersion('radius', disp_rm)
131        self.model.dispersion['radius']['width'] = 5.0
132        self.model.dispersion['radius']['npts'] = 10
133
134        disp_rr = GaussianDispersion()
135        self.model.set_dispersion('thickness', disp_rr)
136        self.model.dispersion['thickness']['width'] = 2.
137        self.model.dispersion['thickness']['npts'] = 10
138
139        disp_len = GaussianDispersion()
140        self.model.set_dispersion('length', disp_len)
141        self.model.dispersion['length']['width'] = 50.0
142        self.model.dispersion['length']['npts'] = 10
143
144        self.assertAlmostEqual(self.model.run(0.001), 358.44062724936009, 3)
145        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 360.22673635224584, 3)
146       
147
148    def test_array(self):
149        """
150            Perform complete rotational average and
151            compare to 1D
152        """
153        from sans.models.dispersion_models import ArrayDispersion
154        disp_ph = ArrayDispersion()
155        disp_th = ArrayDispersion()
156       
157        values_ph = numpy.zeros(100)
158        values_th = numpy.zeros(100)
159        weights   = numpy.zeros(100)
160        for i in range(100):
161            values_ph[i]=(2.0*math.pi/99.0*i)
162            values_th[i]=(math.pi/99.0*i)
163            weights[i]=(1.0)
164       
165        disp_ph.set_weights(values_ph, weights)
166        disp_th.set_weights(values_th, weights)
167       
168        self.model.set_dispersion('axis_theta', disp_th)
169        self.model.set_dispersion('axis_phi', disp_ph)
170       
171        val_1d = self.model.run(math.sqrt(0.0002))
172        val_2d = self.model.runXY([0.01,0.01]) 
173       
174        self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
175       
176       
177       
178class TestCoreShell(unittest.TestCase):
179    """
180        Testing C++ Cylinder model
181    """
182    def setUp(self):
183        from sans.models.CoreShellModel import CoreShellModel
184        self.model= CoreShellModel()
185       
186        self.model.setParam('scale', 1.0)
187        self.model.setParam('radius', 60.0)
188        self.model.setParam('thickness', 10.0)
189        self.model.setParam('core_sld', 1.e-6)
190        self.model.setParam('shell_sld', 2.e-6)
191        self.model.setParam('solvent_sld', 3.e-6)
192        self.model.setParam('background', 0.0)
193       
194    def test_simple(self):
195        """
196            Test simple 1D and 2D values
197            Numbers taken from model that passed validation, before
198            the update to C++ underlying class.
199        """
200        self.assertAlmostEqual(self.model.run(0.001), 381.27304697150055, 3)
201        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 380.93779156218682, 3)
202       
203    def test_dispersion(self):
204        """
205            Test with dispersion
206        """
207        from sans.models.DisperseModel import DisperseModel
208        disp = DisperseModel(self.model, ['radius', 'thickness'], [10, 2])
209        disp.setParam('n_pts', 10)
210        self.assertAlmostEqual(disp.run(0.001), 407.344127907553, 3)
211   
212    def test_new_disp(self):
213        from sans.models.dispersion_models import GaussianDispersion
214        disp_rm = GaussianDispersion()
215        self.model.set_dispersion('radius', disp_rm)
216        self.model.dispersion['radius']['width'] = 10.
217        self.model.dispersion['radius']['npts'] = 10
218
219        disp_rr = GaussianDispersion()
220        self.model.set_dispersion('thickness', disp_rr)
221        self.model.dispersion['thickness']['width'] = 2.
222        self.model.dispersion['thickness']['npts'] = 10
223
224
225        self.assertAlmostEqual(self.model.run(0.001), 407.344127907553, 3)
226
227       
228class TestEllipsoid(unittest.TestCase):
229    """
230        Testing C++ Cylinder model
231    """
232    def setUp(self):
233        from sans.models.EllipsoidModel import EllipsoidModel
234        self.model= EllipsoidModel()
235       
236        self.model.setParam('scale', 1.0)
237        self.model.setParam('radius_a', 20.0)
238        self.model.setParam('radius_b', 400.0)
239        self.model.setParam('contrast', 3.e-6)
240        self.model.setParam('background', 0.0)
241        self.model.setParam('axis_theta', 1.57)
242        self.model.setParam('axis_phi', 0.0)
243       
244    def test_simple(self):
245        """
246            Test simple 1D and 2D values
247            Numbers taken from model that passed validation, before
248            the update to C++ underlying class.
249        """
250        self.assertAlmostEqual(self.model.run(0.001), 11808.842896863147, 3)
251        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 11681.990374929677, 3)
252
253    def test_dispersion(self):
254        """
255            Test with dispersion
256        """
257        from sans.models.DisperseModel import DisperseModel
258        disp = DisperseModel(self.model, ['radius_a', 'radius_b'], [5, 50])
259        disp.setParam('n_pts', 10)
260        self.assertAlmostEqual(disp.run(0.001), 11948.72581312305, 3)
261        self.assertAlmostEqual(disp.runXY([0.001,0.001]), 11811.972359807551, 3)
262       
263    def test_new_disp(self):
264        from sans.models.dispersion_models import GaussianDispersion
265        disp_rm = GaussianDispersion()
266        self.model.set_dispersion('radius_a', disp_rm)
267        self.model.dispersion['radius_a']['width'] = 5.0
268        self.model.dispersion['radius_a']['npts'] = 10
269
270        disp_rr = GaussianDispersion()
271        self.model.set_dispersion('radius_b', disp_rr)
272        self.model.dispersion['radius_b']['width'] = 50.
273        self.model.dispersion['radius_b']['npts'] = 10
274
275
276        self.assertAlmostEqual(self.model.run(0.001), 11948.72581312305, 3)
277        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 11811.972359807551, 3)
278
279    def test_array(self):
280        """
281            Perform complete rotational average and
282            compare to 1D
283        """
284        from sans.models.dispersion_models import ArrayDispersion
285        disp_ph = ArrayDispersion()
286        disp_th = ArrayDispersion()
287       
288        values_ph = numpy.zeros(100)
289        values_th = numpy.zeros(100)
290        weights   = numpy.zeros(100)
291        for i in range(100):
292            values_ph[i]=(2.0*math.pi/99.0*i)
293            values_th[i]=(math.pi/99.0*i)
294            weights[i]=(1.0)
295       
296        disp_ph.set_weights(values_ph, weights)
297        disp_th.set_weights(values_th, weights)
298       
299        self.model.set_dispersion('axis_theta', disp_th)
300        self.model.set_dispersion('axis_phi', disp_ph)
301       
302        val_1d = self.model.run(math.sqrt(0.0002))
303        val_2d = self.model.runXY([0.01,0.01]) 
304       
305        self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
306       
307       
308       
309class TestSphere(unittest.TestCase):
310    """
311        Testing C++ Cylinder model
312    """
313    def setUp(self):
314        from sans.models.SphereModel import SphereModel
315        self.model= SphereModel()
316       
317        self.model.setParam('scale', 1.0)
318        self.model.setParam('radius', 60.0)
319        self.model.setParam('contrast', 1)
320        self.model.setParam('background', 0.0)
321       
322    def test_simple(self):
323        """
324            Test simple 1D and 2D values
325            Numbers taken from model that passed validation, before
326            the update to C++ underlying class.
327        """
328        self.assertAlmostEqual(self.model.run(0.001), 90412744456148.094, 3)
329        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 90347660670656.391, 3)
330
331    def test_dispersion(self):
332        """
333            Test with dispersion
334        """
335        from sans.models.DisperseModel import DisperseModel
336        disp = DisperseModel(self.model, ['radius'], [10])
337        disp.setParam('n_pts', 10)
338        self.assertAlmostEqual(disp.run(0.001), 96795008379475.25, 3)
339       
340    def test_new_disp(self):
341        from sans.models.dispersion_models import GaussianDispersion
342        disp_rm = GaussianDispersion()
343        self.model.set_dispersion('radius', disp_rm)
344        self.model.dispersion['radius']['width'] = 10.0
345        self.model.dispersion['radius']['npts'] = 10
346
347        self.assertAlmostEqual(self.model.run(0.001), 96795008379475.25, 3)
348       
349       
350       
351class TestEllipticalCylinder(unittest.TestCase):
352    """
353        Testing C++ Cylinder model
354    """
355    def setUp(self):
356        from sans.models.EllipticalCylinderModel import EllipticalCylinderModel
357        self.model= EllipticalCylinderModel()
358       
359        self.model.setParam('scale', 1.0)
360        self.model.setParam('r_minor', 20.0)
361        self.model.setParam('r_ratio', 1.5)
362        self.model.setParam('length', 400.0)
363        self.model.setParam('contrast', 3.e-6)
364        self.model.setParam('background', 0.0)
365        self.model.setParam('cyl_theta', 1.57)
366        self.model.setParam('cyl_phi', 0.0)
367        self.model.setParam('cyl_psi', 0.0)
368       
369    def test_simple(self):
370        """
371            Test simple 1D and 2D values
372            Numbers taken from model that passed validation, before
373            the update to C++ underlying class.
374        """
375        self.assertAlmostEqual(self.model.run(0.001), 675.50440232504991, 3)
376        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 669.5173937622792, 3)
377       
378    def test_dispersion(self):
379        """
380            Test with dispersion
381        """
382        from sans.models.DisperseModel import DisperseModel
383        disp = DisperseModel(self.model, ['r_minor', 'r_ratio', 'length'], [5, 0.25, 50])
384        disp.setParam('n_pts', 10)
385        self.assertAlmostEqual(disp.run(0.001), 711.18048194151925, 3)
386        self.assertAlmostEqual(disp.runXY([0.001,0.001]), 704.63525988095705, 3)
387
388    def test_new_disp(self):
389        from sans.models.dispersion_models import GaussianDispersion
390        disp_rm = GaussianDispersion()
391        self.model.set_dispersion('r_minor', disp_rm)
392        self.model.dispersion['r_minor']['width'] = 5.0
393        self.model.dispersion['r_minor']['npts'] = 10
394
395        disp_rr = GaussianDispersion()
396        self.model.set_dispersion('r_ratio', disp_rr)
397        self.model.dispersion['r_ratio']['width'] = 0.25
398        self.model.dispersion['r_ratio']['npts'] = 10
399
400        disp_len = GaussianDispersion()
401        self.model.set_dispersion('length', disp_len)
402        self.model.dispersion['length']['width'] = 50.0
403        self.model.dispersion['length']['npts'] = 10
404
405        self.assertAlmostEqual(self.model.run(0.001), 711.18048194151925, 3)
406        self.assertAlmostEqual(self.model.runXY([0.001,0.001]), 704.63525988095705, 3)
407       
408
409    def test_array(self):
410        """
411            Perform complete rotational average and
412            compare to 1D
413        """
414        from sans.models.dispersion_models import ArrayDispersion
415        disp_ph = ArrayDispersion()
416        disp_th = ArrayDispersion()
417        disp_ps = ArrayDispersion()
418       
419        values_ph = numpy.zeros(100)
420        values_th = numpy.zeros(100)
421        values_ps = numpy.zeros(100)
422        weights   = numpy.zeros(100)
423        for i in range(100):
424            values_ps[i]=(2.0*math.pi/99.0*i)
425            values_ph[i]=(2.0*math.pi/99.0*i)
426            values_th[i]=(math.pi/99.0*i)
427            weights[i]=(1.0)
428       
429        disp_ph.set_weights(values_ph, weights)
430        disp_th.set_weights(values_th, weights)
431        disp_ps.set_weights(values_ps, weights)
432       
433        self.model.set_dispersion('cyl_theta', disp_th)
434        self.model.set_dispersion('cyl_phi', disp_ph)
435        self.model.set_dispersion('cyl_psi', disp_ps)
436       
437        val_1d = self.model.run(math.sqrt(0.0002))
438        val_2d = self.model.runXY([0.01,0.01]) 
439       
440        self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
441       
442class TestDispModel(unittest.TestCase):
443    def setUp(self):
444        from sans.models.CylinderModel import CylinderModel
445        self.model = CylinderModel()
446       
447       
448    def test_disp_params(self):
449       
450        self.assertEqual(self.model.dispersion['radius']['width'], 0.0)
451        self.model.setParam('radius.width', 5.0)
452        self.assertEqual(self.model.dispersion['radius']['width'], 5.0)
453        self.assertEqual(self.model.getParam('radius.width'), 5.0)
454        self.assertEqual(self.model.dispersion['radius']['type'], 'gaussian')
455       
456 
457if __name__ == '__main__':
458    unittest.main()
459   
Note: See TracBrowser for help on using the repository browser.