source: sasview/test/sasrealspace/test/utest_oriented.py @ 1cdbcd8

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalcmagnetic_scattrelease-4.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 1cdbcd8 was 1cdbcd8, checked in by Paul Kienzle <pkienzle@…>, 2 years ago

move tests to use sasmodels rather than sas.models (tests will still fail)

  • Property mode set to 100644
File size: 15.7 KB
Line 
1"""
2    Unit tests for specific oriented models
3    @copyright: University of Tennessee, for the DANSE project
4"""
5from __future__ import print_function
6
7import unittest, math, sys
8
9# Disable "missing docstring" complaint
10# pylint: disable-msg=C0111
11# Disable "too many methods" complaint
12# pylint: disable-msg=R0904
13# Disable "could be a function" complaint
14# pylint: disable-msg=R0201
15# pylint: disable-msg=W0702
16
17from sasmodels.sasview_model import _make_standard_model
18EllipsoidModel = _make_standard_model('ellipsoid')
19SphereModel = _make_standard_model('sphere')
20CylinderModel = _make_standard_model('cylinder')
21CoreShellModel = _make_standard_model('core_shell_sphere')
22
23import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas
24
25
26
27class TestSphere(unittest.TestCase):
28    """ Tests for oriented (2D) systems """
29
30    def setUp(self):
31        """
32            Set up canvas
33        """
34        self.model = VolumeCanvas.VolumeCanvas()
35
36        handle = self.model.add('sphere')
37
38        radius = 10
39        density = .1
40
41        ana = SphereModel()
42        ana.setParam('scale', 1.0)
43        ana.setParam('background', 0.0)
44        ana.setParam('sld', 1.0)
45        ana.setParam('sld_solvent', 0.0)
46        ana.setParam('radius', radius)
47        self.ana = ana
48
49        self.model.setParam('lores_density', density)
50        self.model.setParam('scale' , 1.0)
51        self.model.setParam('background' , 0.0)
52        self.model.setParam('%s.contrast' % handle, 1.0)
53        self.model.setParam('%s.radius' % handle, radius)
54
55
56    def testdefault(self):
57        """ Testing sphere """
58        # Default orientation
59        ana_val = self.ana.runXY([0.1, 0.1])
60        sim_val = self.model.getIq2D(0.1, 0.1)
61        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.1 )
62
63class TestCylinderAddObject(unittest.TestCase):
64    """ Tests for oriented (2D) systems """
65
66    def setUp(self):
67        """ Set up cylinder model """
68        radius = 5
69        length = 40
70        density = 20
71
72        # Analytical model
73        self.ana = CylinderModel()
74        self.ana.setParam('scale', 1.0)
75        self.ana.setParam('background', 0.0)
76        self.ana.setParam('sld', 1.0)
77        self.ana.setParam('sld_solvent', 0.0)
78        self.ana.setParam('radius', radius)
79        self.ana.setParam('length', length)
80
81        # Simulation model
82        self.model = VolumeCanvas.VolumeCanvas()
83        cyl = VolumeCanvas.CylinderDescriptor()
84        self.handle = self.model.addObject(cyl)
85        self.model.setParam('lores_density', density)
86        self.model.setParam('scale' , 1.0)
87        self.model.setParam('background' , 0.0)
88        self.model.setParam('%s.contrast' % self.handle, 1.0)
89        self.model.setParam('%s.radius' % self.handle, radius)
90        self.model.setParam('%s.length' % self.handle, length)
91
92    def testalongY(self):
93        """ Testing cylinder along Y axis """
94        self.ana.setParam('theta', math.pi/2.0)
95        self.ana.setParam('phi', math.pi/2.0)
96
97        self.model.setParam('%s.orientation' % self.handle, [0,0,0])
98
99        ana_val = self.ana.runXY([0.1, 0.2])
100        sim_val = self.model.getIq2D(0.1, 0.2)
101        #print ana_val, sim_val, sim_val/ana_val
102
103        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
104
105
106class TestCylinder(unittest.TestCase):
107    """ Tests for oriented (2D) systems """
108
109    def setUp(self):
110        """ Set up cylinder model """
111        radius = 5
112        length = 40
113        density = 20
114
115        # Analytical model
116        self.ana = CylinderModel()
117        self.ana.setParam('scale', 1.0)
118        self.ana.setParam('background', 0.0)
119        self.ana.setParam('sld', 1.0)
120        self.ana.setParam('sld_solvent', 0.0)
121        self.ana.setParam('radius', radius)
122        self.ana.setParam('length', length)
123
124        # Simulation model
125        self.model = VolumeCanvas.VolumeCanvas()
126        self.handle = self.model.add('cylinder')
127        self.model.setParam('lores_density', density)
128        self.model.setParam('scale' , 1.0)
129        self.model.setParam('background' , 0.0)
130        self.model.setParam('%s.radius' % self.handle, radius)
131        self.model.setParam('%s.length' % self.handle, length)
132        self.model.setParam('%s.contrast' % self.handle, 1.0)
133
134    def testalongY(self):
135        """ Testing cylinder along Y axis """
136        self.ana.setParam('theta', math.pi/2.0)
137        self.ana.setParam('phi', math.pi/2.0)
138
139        self.model.setParam('%s.orientation' % self.handle, [0,0,0])
140
141        ana_val = self.ana.runXY([0.1, 0.2])
142        sim_val = self.model.getIq2D(0.1, 0.2)
143        #print ana_val, sim_val, sim_val/ana_val
144
145        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
146
147    def testalongZ(self):
148        """ Testing cylinder along Z axis """
149        self.ana.setParam('theta', 0)
150        self.ana.setParam('phi', 0)
151
152        self.model.setParam('%s.orientation' % self.handle, [90,0,0])
153
154        ana_val = self.ana.runXY([0.1, 0.2])
155        sim_val = self.model.getIq2D(0.1, 0.2)
156        #print ana_val, sim_val, sim_val/ana_val
157
158        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
159
160    def testalongX(self):
161        """ Testing cylinder along X axis """
162        self.ana.setParam('theta', 1.57)
163        self.ana.setParam('phi', 0)
164
165        self.model.setParam('%s.orientation' % self.handle, [0,0,90])
166
167        ana_val = self.ana.runXY([0.1, 0.2])
168        sim_val = self.model.getIq2D(0.1, 0.2)
169        #print ana_val, sim_val, sim_val/ana_val
170
171        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
172
173class TestEllipsoid(unittest.TestCase):
174    """ Tests for oriented (2D) systems """
175
176    def setUp(self):
177        """ Set up ellipsoid """
178
179        radius_a = 60
180        radius_b = 10
181        density = 30
182
183        self.ana = EllipsoidModel()
184        self.ana.setParam('scale', 1.0)
185        self.ana.setParam('background', 0.0)
186        self.ana.setParam('sld', 1.0)
187        self.ana.setParam('sld_solvent', 0.0)
188        self.ana.setParam('radius_polar', radius_a)
189        self.ana.setParam('radius_equatorial', radius_b)
190        # Default orientation is there=1.57, phi=0
191        # Radius_a is along the x direction
192
193        canvas = VolumeCanvas.VolumeCanvas()
194        self.handle = canvas.add('ellipsoid')
195        canvas.setParam('lores_density', density)
196        canvas.setParam('scale' , 1.0)
197        canvas.setParam('background' , 0.0)
198        canvas.setParam('%s.radius_x' % self.handle, radius_a)
199        canvas.setParam('%s.radius_y' % self.handle, radius_b)
200        canvas.setParam('%s.radius_z' % self.handle, radius_b)
201        canvas.setParam('%s.contrast' % self.handle, 1.0)
202        self.canvas = canvas
203
204    def testalongX(self):
205        """ Testing ellipsoid along X """
206        self.ana.setParam('theta', 1.57)
207        self.ana.setParam('phi', 0)
208
209        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0])
210
211        ana_val = self.ana.runXY([0.1, 0.2])
212        sim_val = self.canvas.getIq2D(0.1, 0.2)
213        #print ana_val, sim_val, sim_val/ana_val
214
215        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
216
217    def testalongZ(self):
218        """ Testing ellipsoid along Z """
219        self.ana.setParam('theta', 0)
220        self.ana.setParam('phi', 0)
221
222        self.canvas.setParam('%s.orientation' % self.handle, [0,90,0])
223
224        ana_val = self.ana.runXY([0.1, 0.2])
225        sim_val = self.canvas.getIq2D(0.1, 0.2)
226        #print ana_val, sim_val, sim_val/ana_val
227
228        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
229
230    def testalongY(self):
231        """ Testing ellipsoid along Y """
232        self.ana.setParam('theta', math.pi/2.0)
233        self.ana.setParam('phi', math.pi/2.0)
234
235        self.canvas.setParam('%s.orientation' % self.handle, [0,0,90])
236
237        ana_val = self.ana.runXY([0.05, 0.15])
238        sim_val = self.canvas.getIq2D(0.05, 0.15)
239        #print ana_val, sim_val, sim_val/ana_val
240
241        try:
242            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
243        except Exception:
244            print("Error", ana_val, sim_val, sim_val/ana_val)
245            raise
246
247class TestCoreShell(unittest.TestCase):
248    """ Tests for oriented (2D) systems """
249
250    def setUp(self):
251        """ Set up zero-SLD-average core-shell model """
252
253        radius = 15
254        thickness = 5
255        density = 20
256
257        core_vol = 4.0/3.0*math.pi*radius*radius*radius
258        self.outer_radius = radius+thickness
259        shell_vol = 4.0/3.0*math.pi*self.outer_radius*self.outer_radius*self.outer_radius - core_vol
260        self.shell_sld = -1.0*core_vol/shell_vol
261
262        self.density = density
263
264        # Core-shell
265        sphere = CoreShellModel()
266        sphere.setParam('scale', 1.0)
267        sphere.setParam('background', 0.0)
268        # Core radius
269        sphere.setParam('radius', radius)
270        # Shell thickness
271        sphere.setParam('thickness', thickness)
272        sphere.setParam('sld_core', 1.0)
273        sphere.setParam('sld_shell', self.shell_sld)
274        sphere.setParam('sld_solvent', 0.0)
275        self.ana = sphere
276
277        canvas = VolumeCanvas.VolumeCanvas()
278        canvas.setParam('lores_density', self.density)
279        canvas.setParam('scale' , 1.0)
280        canvas.setParam('background' , 0.0)
281
282        handle = canvas.add('sphere')
283        canvas.setParam('%s.radius' % handle, self.outer_radius)
284        canvas.setParam('%s.contrast' % handle, self.shell_sld)
285
286        handle2 = canvas.add('sphere')
287        canvas.setParam('%s.radius' % handle2, radius)
288        canvas.setParam('%s.contrast' % handle2, 1.0)
289
290        self.canvas = canvas
291
292    def testdefault(self):
293        """ Testing default core-shell orientation """
294        ana_val = self.ana.runXY([0.1, 0.2])
295        sim_val, err = self.canvas.getIq2DError(0.1, 0.2)
296
297        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
298
299class TestCoreShellError(unittest.TestCase):
300    """ Tests for oriented (2D) systems """
301
302    def setUp(self):
303        """ Set up zero-SLD-average core-shell model """
304
305        radius = 15
306        thickness = 5
307        density = 5
308
309        core_vol = 4.0/3.0*math.pi*radius*radius*radius
310        self.outer_radius = radius+thickness
311        shell_vol = 4.0/3.0*math.pi*self.outer_radius*self.outer_radius*self.outer_radius - core_vol
312        self.shell_sld = -1.0*core_vol/shell_vol
313
314        self.density = density
315
316        # Core-shell
317        sphere = CoreShellModel()
318        sphere.setParam('scale', 1.0)
319        sphere.setParam('background', 0.0)
320        # Core radius
321        sphere.setParam('radius', radius)
322        # Shell thickness
323        sphere.setParam('thickness', thickness)
324        sphere.setParam('sld_core', 1.0)
325        sphere.setParam('sld_shell', self.shell_sld)
326        sphere.setParam('sld_solvent', 0.0)
327        self.ana = sphere
328
329        canvas = VolumeCanvas.VolumeCanvas()
330        canvas.setParam('lores_density', self.density)
331        canvas.setParam('scale' , 1.0)
332        canvas.setParam('background' , 0.0)
333
334        handle = canvas.add('sphere')
335        canvas.setParam('%s.radius' % handle, self.outer_radius)
336        canvas.setParam('%s.contrast' % handle, self.shell_sld)
337
338        handle2 = canvas.add('sphere')
339        canvas.setParam('%s.radius' % handle2, radius)
340        canvas.setParam('%s.contrast' % handle2, 1.0)
341
342        self.canvas = canvas
343
344    def testdefault(self):
345        """ Testing default core-shell orientation """
346        ana_val = self.ana.runXY([0.1, 0.2])
347        sim_val, err = self.canvas.getIq2DError(0.1, 0.2)
348
349        self.assert_( math.fabs(sim_val-ana_val) < 3.0 * err )
350
351class TestRunMethods(unittest.TestCase):
352    """ Tests run methods for oriented (2D) systems """
353
354    def setUp(self):
355        """ Set up ellipsoid """
356
357        radius_a = 10
358        radius_b = 15
359        density = 5
360
361        self.ana = EllipsoidModel()
362        self.ana.setParam('scale', 1.0)
363        self.ana.setParam('background', 0.0)
364        self.ana.setParam('sld', 1.0)
365        self.ana.setParam('sld_solvent', 1.0)
366        self.ana.setParam('radius_polar', radius_a)
367        self.ana.setParam('radius_equatorial', radius_b)
368
369
370        canvas = VolumeCanvas.VolumeCanvas()
371        self.handle = canvas.add('ellipsoid')
372        canvas.setParam('lores_density', density)
373        canvas.setParam('scale' , 1.0)
374        canvas.setParam('background' , 0.0)
375        canvas.setParam('%s.radius_x' % self.handle, radius_a)
376        canvas.setParam('%s.radius_y' % self.handle, radius_b)
377        canvas.setParam('%s.radius_z' % self.handle, radius_b)
378        canvas.setParam('%s.contrast' % self.handle, 1.0)
379        self.canvas = canvas
380
381        self.ana.setParam('theta', 1.57)
382        self.ana.setParam('phi', 0)
383
384        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0])
385
386
387    def testRunXY_List(self):
388        """ Testing ellipsoid along X """
389        ana_val = self.ana.runXY([0.1, 0.2])
390        sim_val = self.canvas.runXY([0.1, 0.2])
391        #print ana_val, sim_val, sim_val/ana_val
392
393        try:
394            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
395        except Exception:
396            print("Error", ana_val, sim_val, sim_val/ana_val)
397            raise
398
399    def testRunXY_float(self):
400        """ Testing ellipsoid along X """
401        ana_val = self.ana.runXY(0.1)
402        sim_val = self.canvas.runXY(0.1)
403        #print ana_val, sim_val, sim_val/ana_val
404
405        try:
406            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
407        except Exception:
408            print("Error", ana_val, sim_val, sim_val/ana_val)
409            raise
410
411    def testRun_float(self):
412        """ Testing ellipsoid along X """
413        ana_val = self.ana.run(0.1)
414        sim_val = self.canvas.run(0.1)
415        #print ana_val, sim_val, sim_val/ana_val
416
417        try:
418            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
419        except Exception:
420            print("Error", ana_val, sim_val, sim_val/ana_val)
421            raise
422
423    def testRun_list(self):
424        """ Testing ellipsoid along X """
425        ana_val = self.ana.run([0.1, 33.0])
426        sim_val = self.canvas.run([0.1, 33.0])
427        #print ana_val, sim_val, sim_val/ana_val
428
429        try:
430            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
431        except Exception:
432            print("Error", ana_val, sim_val, sim_val/ana_val)
433            raise
434
435class TestParamChange(unittest.TestCase):
436    """ Tests for oriented (2D) systems """
437
438    def setUp(self):
439        """ Set up cylinder model """
440        radius = 5
441        length = 40
442        density = 20
443
444        # Analytical model
445        self.ana = CylinderModel()
446        self.ana.setParam('scale', 1.0)
447        self.ana.setParam('background', 0.0)
448        self.ana.setParam('sld', 1.0)
449        self.ana.setParam('sld_solvent', 0.0)
450        self.ana.setParam('radius', radius)
451        self.ana.setParam('length', length)
452        self.ana.setParam('theta', math.pi/2.0)
453        self.ana.setParam('phi', math.pi/2.0)
454
455        # Simulation model
456        self.model = VolumeCanvas.VolumeCanvas()
457        self.handle = self.model.add('cylinder')
458        self.model.setParam('lores_density', density)
459        self.model.setParam('scale' , 1.0)
460        self.model.setParam('background' , 0.0)
461        self.model.setParam('%s.radius' % self.handle, radius)
462        self.model.setParam('%s.length' % self.handle, length)
463        self.model.setParam('%s.contrast' % self.handle, 1.0)
464        self.model.setParam('%s.orientation' % self.handle, [0,0,0])
465
466    def testalongY(self):
467        """ Test that a parameter change forces the generation
468            of new space points
469        """
470        ana_val = self.ana.runXY([0.1, 0.2])
471        sim_val = self.model.getIq2D(0.1, 0.2)
472
473        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
474
475        # Change the radius a re-evaluate
476        self.ana.setParam('radius', 10)
477        self.model.setParam('%s.radius' % self.handle, 10)
478
479        ana_val = self.ana.runXY([0.1, 0.2])
480        sim_val = self.model.getIq2D(0.1, 0.2)
481        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
482
483
484if __name__ == '__main__':
485    unittest.main()
Note: See TracBrowser for help on using the repository browser.