source: sasview/test/sasrealspace/test/utest_oriented.py @ aaf5e49

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.2.2ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since aaf5e49 was aaf5e49, checked in by andyfaff, 2 years ago

MAINT: few more print instances

  • Property mode set to 100644
File size: 16.6 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
17try:
18    import VolumeCanvas
19    print("Testing local version")
20except:
21    print(sys.exc_value)
22    #testing the version that is working on
23    print("Testing installed version")
24    import sas.sascalc.realspace.VolumeCanvas as VolumeCanvas
25 
26
27class TestSphere(unittest.TestCase):
28    """ Tests for oriented (2D) systems """
29       
30    def setUp(self):
31        """
32            Set up canvas
33        """
34        from sas.models.SphereModel import SphereModel
35        self.model = VolumeCanvas.VolumeCanvas()
36   
37        handle = self.model.add('sphere')
38       
39        radius = 10
40        density = .1
41       
42        ana = SphereModel()
43        ana.setParam('scale', 1.0)
44        ana.setParam('contrast', 1.0)
45        ana.setParam('background', 0.0)
46        ana.setParam('radius', radius)
47        self.ana = ana
48       
49        self.model.setParam('lores_density', density)
50        self.model.setParam('%s.radius' % handle, radius)
51        self.model.setParam('scale' , 1.0)
52        self.model.setParam('%s.contrast' % handle, 1.0)
53        self.model.setParam('background' , 0.0)
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        from sas.models.CylinderModel import CylinderModel
69        radius = 5
70        length = 40
71        density = 20
72   
73        # Analytical model
74        self.ana = CylinderModel()
75        self.ana.setParam('scale', 1.0)
76        self.ana.setParam('contrast', 1.0)
77        self.ana.setParam('background', 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('%s.radius' % self.handle, radius)
87        self.model.setParam('%s.length' % self.handle, length)
88        self.model.setParam('scale' , 1.0)
89        self.model.setParam('%s.contrast' % self.handle, 1.0)
90        self.model.setParam('background' , 0.0)
91   
92    def testalongY(self):
93        """ Testing cylinder along Y axis """
94        self.ana.setParam('cyl_theta', math.pi/2.0)
95        self.ana.setParam('cyl_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        from sas.models.CylinderModel import CylinderModel
112        radius = 5
113        length = 40
114        density = 20
115   
116        # Analytical model
117        self.ana = CylinderModel()
118        self.ana.setParam('scale', 1.0)
119        self.ana.setParam('contrast', 1.0)
120        self.ana.setParam('background', 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('%s.radius' % self.handle, radius)
129        self.model.setParam('%s.length' % self.handle, length)
130        self.model.setParam('scale' , 1.0)
131        self.model.setParam('%s.contrast' % self.handle, 1.0)
132        self.model.setParam('background' , 0.0)
133   
134    def testalongY(self):
135        """ Testing cylinder along Y axis """
136        self.ana.setParam('cyl_theta', math.pi/2.0)
137        self.ana.setParam('cyl_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('cyl_theta', 0)
150        self.ana.setParam('cyl_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('cyl_theta', 1.57)
163        self.ana.setParam('cyl_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        from sas.models.EllipsoidModel import EllipsoidModel
179       
180        radius_a = 60
181        radius_b = 10
182        density = 30
183       
184        self.ana = EllipsoidModel()
185        self.ana.setParam('scale', 1.0)
186        self.ana.setParam('contrast', 1.0)
187        self.ana.setParam('background', 0.0)
188        self.ana.setParam('radius_a', radius_a)
189        self.ana.setParam('radius_b', 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        canvas.setParam('lores_density', density)
195        self.handle = canvas.add('ellipsoid')
196        canvas.setParam('%s.radius_x' % self.handle, radius_a)
197        canvas.setParam('%s.radius_y' % self.handle, radius_b)
198        canvas.setParam('%s.radius_z' % self.handle, radius_b)
199        canvas.setParam('scale' , 1.0)
200        canvas.setParam('%s.contrast' % self.handle, 1.0)
201        canvas.setParam('background' , 0.0)
202        self.canvas = canvas       
203
204    def testalongX(self):
205        """ Testing ellipsoid along X """
206        self.ana.setParam('axis_theta', 1.57)
207        self.ana.setParam('axis_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('axis_theta', 0)
220        self.ana.setParam('axis_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('axis_theta', math.pi/2.0)
233        self.ana.setParam('axis_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:
244            print("Error", ana_val, sim_val, sim_val/ana_val)
245            raise sys.exc_type, sys.exc_value
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        from sas.models.CoreShellModel import CoreShellModel
253       
254        radius = 15
255        thickness = 5
256        density = 20
257       
258        core_vol = 4.0/3.0*math.pi*radius*radius*radius
259        self.outer_radius = radius+thickness
260        shell_vol = 4.0/3.0*math.pi*self.outer_radius*self.outer_radius*self.outer_radius - core_vol
261        self.shell_sld = -1.0*core_vol/shell_vol
262
263        self.density = density
264           
265        # Core-shell
266        sphere = CoreShellModel()
267        # Core radius
268        sphere.setParam('radius', radius)
269        # Shell thickness
270        sphere.setParam('thickness', thickness)
271        sphere.setParam('core_sld', 1.0)
272        sphere.setParam('shell_sld', self.shell_sld)
273        sphere.setParam('solvent_sld', 0.0)
274        sphere.setParam('background', 0.0)
275        sphere.setParam('scale', 1.0)
276        self.ana = sphere
277       
278        canvas = VolumeCanvas.VolumeCanvas()       
279        canvas.setParam('lores_density', self.density)
280       
281        handle = canvas.add('sphere')
282        canvas.setParam('%s.radius' % handle, self.outer_radius)
283        canvas.setParam('%s.contrast' % handle, self.shell_sld)
284       
285        handle2 = canvas.add('sphere')
286        canvas.setParam('%s.radius' % handle2, radius)
287        canvas.setParam('%s.contrast' % handle2, 1.0)
288               
289        canvas.setParam('scale' , 1.0)
290        canvas.setParam('background' , 0.0)
291        self.canvas = canvas
292           
293    def testdefault(self):
294        """ Testing default core-shell orientation """
295        ana_val = self.ana.runXY([0.1, 0.2])
296        sim_val, err = self.canvas.getIq2DError(0.1, 0.2)
297       
298        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
299                   
300class TestCoreShellError(unittest.TestCase):
301    """ Tests for oriented (2D) systems """
302       
303    def setUp(self):
304        """ Set up zero-SLD-average core-shell model """
305        from sas.models.CoreShellModel import CoreShellModel
306       
307        radius = 15
308        thickness = 5
309        density = 5
310       
311        core_vol = 4.0/3.0*math.pi*radius*radius*radius
312        self.outer_radius = radius+thickness
313        shell_vol = 4.0/3.0*math.pi*self.outer_radius*self.outer_radius*self.outer_radius - core_vol
314        self.shell_sld = -1.0*core_vol/shell_vol
315
316        self.density = density
317           
318        # Core-shell
319        sphere = CoreShellModel()
320        # Core radius
321        sphere.setParam('radius', radius)
322        # Shell thickness
323        sphere.setParam('thickness', thickness)
324        sphere.setParam('core_sld', 1.0)
325        sphere.setParam('shell_sld', self.shell_sld)
326        sphere.setParam('solvent_sld', 0.0)
327        sphere.setParam('background', 0.0)
328        sphere.setParam('scale', 1.0)
329        self.ana = sphere
330       
331        canvas = VolumeCanvas.VolumeCanvas()       
332        canvas.setParam('lores_density', self.density)
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        canvas.setParam('scale' , 1.0)
343        canvas.setParam('background' , 0.0)
344        self.canvas = canvas
345                   
346    def testdefault(self):
347        """ Testing default core-shell orientation """
348        ana_val = self.ana.runXY([0.1, 0.2])
349        sim_val, err = self.canvas.getIq2DError(0.1, 0.2)
350       
351        self.assert_( math.fabs(sim_val-ana_val) < 3.0 * err )
352
353class TestRunMethods(unittest.TestCase):
354    """ Tests run methods for oriented (2D) systems """
355
356    def setUp(self):
357        """ Set up ellipsoid """
358        from sas.models.EllipsoidModel import EllipsoidModel
359       
360        radius_a = 10
361        radius_b = 15
362        density = 5
363       
364        self.ana = EllipsoidModel()
365        self.ana.setParam('scale', 1.0)
366        self.ana.setParam('contrast', 1.0)
367        self.ana.setParam('background', 0.0)
368        self.ana.setParam('radius_a', radius_a)
369        self.ana.setParam('radius_b', radius_b)
370
371       
372        canvas = VolumeCanvas.VolumeCanvas()
373        canvas.setParam('lores_density', density)
374        self.handle = canvas.add('ellipsoid')
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('scale' , 1.0)
379        canvas.setParam('%s.contrast' % self.handle, 1.0)
380        canvas.setParam('background' , 0.0)
381        self.canvas = canvas     
382           
383        self.ana.setParam('axis_theta', 1.57)
384        self.ana.setParam('axis_phi', 0)
385       
386        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0])
387       
388
389    def testRunXY_List(self):
390        """ Testing ellipsoid along X """
391        ana_val = self.ana.runXY([0.1, 0.2])
392        sim_val = self.canvas.runXY([0.1, 0.2])
393        #print ana_val, sim_val, sim_val/ana_val
394       
395        try:
396            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
397        except:
398            print("Error", ana_val, sim_val, sim_val/ana_val)
399            raise sys.exc_type, sys.exc_value
400
401    def testRunXY_float(self):
402        """ Testing ellipsoid along X """
403        ana_val = self.ana.runXY(0.1)
404        sim_val = self.canvas.runXY(0.1)
405        #print ana_val, sim_val, sim_val/ana_val
406       
407        try:
408            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
409        except:
410            print("Error", ana_val, sim_val, sim_val/ana_val)
411            raise sys.exc_type, sys.exc_value
412
413    def testRun_float(self):
414        """ Testing ellipsoid along X """
415        ana_val = self.ana.run(0.1)
416        sim_val = self.canvas.run(0.1)
417        #print ana_val, sim_val, sim_val/ana_val
418       
419        try:
420            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
421        except:
422            print("Error", ana_val, sim_val, sim_val/ana_val)
423            raise sys.exc_type, sys.exc_value
424
425    def testRun_list(self):
426        """ Testing ellipsoid along X """
427        ana_val = self.ana.run([0.1, 33.0])
428        sim_val = self.canvas.run([0.1, 33.0])
429        #print ana_val, sim_val, sim_val/ana_val
430       
431        try:
432            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
433        except:
434            print("Error", ana_val, sim_val, sim_val/ana_val)
435            raise sys.exc_type, sys.exc_value
436
437class TestParamChange(unittest.TestCase):
438    """ Tests for oriented (2D) systems """
439       
440    def setUp(self):
441        """ Set up cylinder model """
442        from sas.models.CylinderModel import CylinderModel
443        radius = 5
444        length = 40
445        density = 20
446   
447        # Analytical model
448        self.ana = CylinderModel()
449        self.ana.setParam('scale', 1.0)
450        self.ana.setParam('contrast', 1.0)
451        self.ana.setParam('background', 0.0)
452        self.ana.setParam('radius', radius)
453        self.ana.setParam('length', length)
454        self.ana.setParam('cyl_theta', math.pi/2.0)
455        self.ana.setParam('cyl_phi', math.pi/2.0)
456   
457        # Simulation model
458        self.model = VolumeCanvas.VolumeCanvas()
459        self.handle = self.model.add('cylinder')
460        self.model.setParam('lores_density', density)
461        self.model.setParam('%s.radius' % self.handle, radius)
462        self.model.setParam('%s.length' % self.handle, length)
463        self.model.setParam('scale' , 1.0)
464        self.model.setParam('%s.contrast' % self.handle, 1.0)
465        self.model.setParam('background' , 0.0)
466        self.model.setParam('%s.orientation' % self.handle, [0,0,0])
467   
468    def testalongY(self):
469        """ Test that a parameter change forces the generation
470            of new space points
471        """
472        ana_val = self.ana.runXY([0.1, 0.2])
473        sim_val = self.model.getIq2D(0.1, 0.2)
474       
475        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
476       
477        # Change the radius a re-evaluate
478        self.ana.setParam('radius', 10)
479        self.model.setParam('%s.radius' % self.handle, 10)
480       
481        ana_val = self.ana.runXY([0.1, 0.2])
482        sim_val = self.model.getIq2D(0.1, 0.2)
483        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
484
485
486if __name__ == '__main__':
487    unittest.main()       
Note: See TracBrowser for help on using the repository browser.