source: sasview/sansrealspace/src/realspace/test/utest_oriented.py @ f98961f

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

Updated run() and runXY() to be compatible with the rest of the models
  • Property mode set to 100644
File size: 11.2 KB
Line 
1"""
2    Unit tests for specific oriented models
3    @copyright: University of Tennessee, for the DANSE project
4"""
5
6import unittest, math, sys
7
8# Disable "missing docstring" complaint
9# pylint: disable-msg=C0111
10# Disable "too many methods" complaint
11# pylint: disable-msg=R0904
12# Disable "could be a function" complaint
13# pylint: disable-msg=R0201
14# pylint: disable-msg=W0702
15
16try:
17    import VolumeCanvas
18    print "Testing local version"
19except:
20    print sys.exc_value
21    #testing the version that is working on
22    print "Testing installed version"
23    import sans.realspace.VolumeCanvas as VolumeCanvas
24 
25
26class TestSphere(unittest.TestCase):
27    """ Tests for oriented (2D) systems """
28       
29    def setUp(self):
30        """
31            Set up canvas
32        """
33        from sans.models.SphereModel import SphereModel
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('contrast', 1.0)
44        ana.setParam('background', 0.0)
45        ana.setParam('radius', radius)
46        self.ana = ana
47       
48        self.model.setParam('lores_density', density)
49        self.model.setParam('%s.radius' % handle, radius)
50        self.model.setParam('scale' , 1.0)
51        self.model.setParam('%s.contrast' % handle, 1.0)
52        self.model.setParam('background' , 0.0)
53       
54       
55    def testdefault(self):
56        """ Testing sphere """
57        # Default orientation
58        ana_val = self.ana.runXY([0.1, 0.1])
59        sim_val = self.model.getIq2D(0.1, 0.1)
60        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.1 )
61       
62class TestCylinder(unittest.TestCase):
63    """ Tests for oriented (2D) systems """
64       
65    def setUp(self):
66        """ Set up cylinder model """
67        from sans.models.CylinderModel import CylinderModel
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('contrast', 1.0)
76        self.ana.setParam('background', 0.0)
77        self.ana.setParam('radius', radius)
78        self.ana.setParam('length', length)
79   
80        # Simulation model
81        self.model = VolumeCanvas.VolumeCanvas()
82        self.handle = self.model.add('cylinder')
83        self.model.setParam('lores_density', density)
84        self.model.setParam('%s.radius' % self.handle, radius)
85        self.model.setParam('%s.length' % self.handle, length)
86        self.model.setParam('scale' , 1.0)
87        self.model.setParam('%s.contrast' % self.handle, 1.0)
88        self.model.setParam('background' , 0.0)
89   
90    def testalongY(self):
91        """ Testing cylinder along Y axis """
92        self.ana.setParam('cyl_theta', math.pi/2.0)
93        self.ana.setParam('cyl_phi', math.pi/2.0)
94       
95        self.model.setParam('%s.orientation' % self.handle, [0,0,0])
96       
97        ana_val = self.ana.runXY([0.1, 0.2])
98        sim_val = self.model.getIq2D(0.1, 0.2)
99        #print ana_val, sim_val, sim_val/ana_val
100       
101        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
102       
103    def testalongZ(self):
104        """ Testing cylinder along Z axis """
105        self.ana.setParam('cyl_theta', 0)
106        self.ana.setParam('cyl_phi', 0)
107       
108        self.model.setParam('%s.orientation' % self.handle, [90,0,0])
109       
110        ana_val = self.ana.runXY([0.1, 0.2])
111        sim_val = self.model.getIq2D(0.1, 0.2)
112        #print ana_val, sim_val, sim_val/ana_val
113       
114        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
115       
116    def testalongX(self):
117        """ Testing cylinder along X axis """
118        self.ana.setParam('cyl_theta', 1.57)
119        self.ana.setParam('cyl_phi', 0)
120       
121        self.model.setParam('%s.orientation' % self.handle, [0,0,90])
122       
123        ana_val = self.ana.runXY([0.1, 0.2])
124        sim_val = self.model.getIq2D(0.1, 0.2)
125        #print ana_val, sim_val, sim_val/ana_val
126       
127        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
128       
129class TestEllipsoid(unittest.TestCase):
130    """ Tests for oriented (2D) systems """
131       
132    def setUp(self):
133        """ Set up ellipsoid """
134        from sans.models.EllipsoidModel import EllipsoidModel
135       
136        radius_a = 60
137        radius_b = 10
138        density = 30
139       
140        self.ana = EllipsoidModel()
141        self.ana.setParam('scale', 1.0)
142        self.ana.setParam('contrast', 1.0)
143        self.ana.setParam('background', 0.0)
144        self.ana.setParam('radius_a', radius_a)
145        self.ana.setParam('radius_b', radius_b)
146
147       
148        canvas = VolumeCanvas.VolumeCanvas()
149        canvas.setParam('lores_density', density)
150        self.handle = canvas.add('ellipsoid')
151        canvas.setParam('%s.radius_x' % self.handle, radius_a)
152        canvas.setParam('%s.radius_y' % self.handle, radius_b)
153        canvas.setParam('%s.radius_z' % self.handle, radius_b)
154        canvas.setParam('scale' , 1.0)
155        canvas.setParam('%s.contrast' % self.handle, 1.0)
156        canvas.setParam('background' , 0.0)
157        self.canvas = canvas       
158
159    def testalongX(self):
160        """ Testing ellipsoid along X """
161        self.ana.setParam('axis_theta', 1.57)
162        self.ana.setParam('axis_phi', 0)
163       
164        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0])
165       
166        ana_val = self.ana.runXY([0.1, 0.2])
167        sim_val = self.canvas.getIq2D(0.1, 0.2)
168        #print ana_val, sim_val, sim_val/ana_val
169       
170        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
171
172    def testalongZ(self):
173        """ Testing ellipsoid along Z """
174        self.ana.setParam('axis_theta', 0)
175        self.ana.setParam('axis_phi', 0)
176       
177        self.canvas.setParam('%s.orientation' % self.handle, [0,90,0])
178       
179        ana_val = self.ana.runXY([0.1, 0.2])
180        sim_val = self.canvas.getIq2D(0.1, 0.2)
181        #print ana_val, sim_val, sim_val/ana_val
182       
183        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
184
185    def testalongY(self):
186        """ Testing ellipsoid along Y """
187        self.ana.setParam('axis_theta', math.pi/2.0)
188        self.ana.setParam('axis_phi', math.pi/2.0)
189       
190        self.canvas.setParam('%s.orientation' % self.handle, [0,0,90])
191       
192        ana_val = self.ana.runXY([0.05, 0.15])
193        sim_val = self.canvas.getIq2D(0.05, 0.15)
194        #print ana_val, sim_val, sim_val/ana_val
195       
196        try:
197            self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
198        except:
199            print ana_val, sim_val, sim_val/ana_val
200            raise sys.exc_type, sys.exc_value
201
202class TestCoreShell(unittest.TestCase):
203    """ Tests for oriented (2D) systems """
204       
205    def setUp(self):
206        """ Set up zero-SLD-average core-shell model """
207        from sans.models.CoreShellModel import CoreShellModel
208       
209        radius = 15
210        thickness = 5
211        density = 20
212       
213        core_vol = 4.0/3.0*math.pi*radius*radius*radius
214        self.outer_radius = radius+thickness
215        shell_vol = 4.0/3.0*math.pi*self.outer_radius*self.outer_radius*self.outer_radius - core_vol
216        self.shell_sld = -1.0*core_vol/shell_vol
217
218        self.density = density
219           
220        # Core-shell
221        sphere = CoreShellModel()
222        # Core radius
223        sphere.setParam('radius', radius)
224        # Shell thickness
225        sphere.setParam('thickness', thickness)
226        sphere.setParam('core_sld', 1.0)
227        sphere.setParam('shell_sld', self.shell_sld)
228        sphere.setParam('solvent_sld', 0.0)
229        sphere.setParam('background', 0.0)
230        sphere.setParam('scale', 1.0)
231        self.ana = sphere
232       
233        canvas = VolumeCanvas.VolumeCanvas()       
234        canvas.setParam('lores_density', self.density)
235       
236        handle = canvas.add('sphere')
237        canvas.setParam('%s.radius' % handle, self.outer_radius)
238        canvas.setParam('%s.contrast' % handle, self.shell_sld)
239       
240        handle2 = canvas.add('sphere')
241        canvas.setParam('%s.radius' % handle2, radius)
242        canvas.setParam('%s.contrast' % handle2, 1.0)
243               
244        canvas.setParam('scale' , 1.0)
245        canvas.setParam('background' , 0.0)
246        self.canvas = canvas
247                   
248    def testdefault(self):
249        """ Testing default core-shell orientation """
250        ana_val = self.ana.runXY([0.1, 0.2])
251        sim_val = self.canvas.getIq2D(0.1, 0.2)
252        #print ana_val, sim_val, sim_val/ana_val
253       
254        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
255
256class TestRunMethods(unittest.TestCase):
257    """ Tests run methods for oriented (2D) systems """
258
259    def setUp(self):
260        """ Set up ellipsoid """
261        from sans.models.EllipsoidModel import EllipsoidModel
262       
263        radius_a = 10
264        radius_b = 15
265        density = 1
266       
267        self.ana = EllipsoidModel()
268        self.ana.setParam('scale', 1.0)
269        self.ana.setParam('contrast', 1.0)
270        self.ana.setParam('background', 0.0)
271        self.ana.setParam('radius_a', radius_a)
272        self.ana.setParam('radius_b', radius_b)
273
274       
275        canvas = VolumeCanvas.VolumeCanvas()
276        canvas.setParam('lores_density', density)
277        self.handle = canvas.add('ellipsoid')
278        canvas.setParam('%s.radius_x' % self.handle, radius_a)
279        canvas.setParam('%s.radius_y' % self.handle, radius_b)
280        canvas.setParam('%s.radius_z' % self.handle, radius_b)
281        canvas.setParam('scale' , 1.0)
282        canvas.setParam('%s.contrast' % self.handle, 1.0)
283        canvas.setParam('background' , 0.0)
284        self.canvas = canvas     
285           
286        self.ana.setParam('axis_theta', 1.57)
287        self.ana.setParam('axis_phi', 0)
288       
289        self.canvas.setParam('%s.orientation' % self.handle, [0,0,0])
290       
291
292    def testRunXY_List(self):
293        """ Testing ellipsoid along X """
294        ana_val = self.ana.runXY([0.1, 0.2])
295        sim_val = self.canvas.runXY([0.1, 0.2])
296        #print ana_val, sim_val, sim_val/ana_val
297       
298        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
299
300    def testRunXY_float(self):
301        """ Testing ellipsoid along X """
302        ana_val = self.ana.runXY(0.1)
303        sim_val = self.canvas.runXY(0.1)
304        #print ana_val, sim_val, sim_val/ana_val
305       
306        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
307
308    def testRun_float(self):
309        """ Testing ellipsoid along X """
310        ana_val = self.ana.run(0.1)
311        sim_val = self.canvas.run(0.1)
312        #print ana_val, sim_val, sim_val/ana_val
313       
314        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
315
316    def testRun_list(self):
317        """ Testing ellipsoid along X """
318        ana_val = self.ana.run([0.1, 33.0])
319        sim_val = self.canvas.run([0.1, 33.0])
320        #print ana_val, sim_val, sim_val/ana_val
321       
322        self.assert_( math.fabs(sim_val/ana_val-1.0)<0.05 )
323
324         
325
326
327if __name__ == '__main__':
328    unittest.main()       
Note: See TracBrowser for help on using the repository browser.