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

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 58c6ba6 was eba9885, checked in by Gervaise Alina <gervyh@…>, 15 years ago

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