source: sasview/sansmodels/test/utest_modelmultiplication.py @ bdaa334

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 bdaa334 was bdaa334, checked in by Jae Cho <jhjcho@…>, 12 years ago

calculate_ER() for mutiplicationmodel is finite(=0) now since it retruns as zero (due to warning fix)
  • Property mode set to 100644
File size: 29.9 KB
Line 
1"""
2    Unit tests for specific models
3    @author: JHJ Cho / UTK
4"""
5#This test replaces the older utests for multiplicationModel. Aug. 31, 2009. JC
6import unittest, numpy,math
7### P*S with sphere model   
8class TestsphereSuareW(unittest.TestCase):
9    """
10        Unit tests for SphereModel(Q) * SquareWellStructure(Q)
11    """
12    def setUp(self):
13        from sans.models.SphereModel import SphereModel
14        from sans.models.SquareWellStructure import SquareWellStructure
15        from sans.models.DiamCylFunc import DiamCylFunc
16        from sans.models.MultiplicationModel import MultiplicationModel
17
18        self.model = SphereModel()
19        self.model2 = SquareWellStructure()
20        self.model3 = MultiplicationModel(self.model, self.model2) 
21        self.modelD = DiamCylFunc() 
22
23    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
24    def test_multplication_radius(self):
25        """
26            test multiplication model (check the effective radius & the output
27             of the multiplication)
28        """
29        self.model.setParam("radius", 60)
30        modelDrun = 60
31        self.model2.setParam("volfraction", 0.2)
32        self.model2.setParam("effect_radius", modelDrun )
33       
34        #Compare new method with old method         
35        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
36       
37        #Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
38        self.assertEqual(self.model.calculate_ER(), modelDrun)
39       
40       
41    def testMultiplicationParam(self):
42        """ Test Multiplication  (check the setparameters and the run & runXY w/ array dispersion)"""
43        ## test details dictionary
44
45        ## test parameters list
46        list3= self.model3.getParamList()
47
48        for item in self.model.getParamList():
49            if not 'scale' in item: 
50                self.assert_(item in list3)
51        for item in self.model2.getParamList():
52            #model3 parameters should not include effect_radius*
53            if not 'effect_radius' in item: 
54                self.assert_(item in list3)
55           
56        ## test set value for parameters and get paramaters
57        self.model3.setParam("scale_factor", 15)
58        self.assertEqual(self.model3.getParam("scale_factor"), 15)
59        self.model3.setParam("radius", 20)
60        self.assertEqual(self.model3.getParam("radius"), 20)
61        self.model3.setParam("radius.width", 15)
62        self.assertEqual(self.model3.getParam("radius.width"), 15)
63        self.model3.setParam("scale_factor", 15)
64        self.assertEqual(self.model3.getParam("scale_factor"), 15)
65        self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
66       
67        ## Dispersity
68        list3= self.model3.getDispParamList()
69        self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width'])
70       
71        from sans.models.dispersion_models import ArrayDispersion
72        disp_th = ArrayDispersion()
73       
74        values_th = numpy.zeros(100)
75        weights   = numpy.zeros(100)
76        for i in range(100):
77            values_th[i]=(math.pi/99.0*i)
78            weights[i]=(1.0)
79   
80        disp_th.set_weights(values_th, weights)
81       
82        self.model3.set_dispersion('radius', disp_th)
83       
84        val_1d = self.model3.run(math.sqrt(0.0002))
85        val_2d = self.model3.runXY([0.01,0.01]) 
86       
87        self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
88        model4= self.model3.clone()
89        self.assertEqual(model4.getParam("radius"), 20)
90     
91class TestsphereHardS(unittest.TestCase):
92    """
93        Unit tests for SphereModel(Q) * HardsphereStructure(Q)
94    """
95    def setUp(self):
96        from sans.models.SphereModel import SphereModel
97        from sans.models.HardsphereStructure import HardsphereStructure
98        from sans.models.DiamCylFunc import DiamCylFunc
99        from sans.models.MultiplicationModel import MultiplicationModel
100
101        self.model = SphereModel()
102        self.model2 = HardsphereStructure()
103        self.model3 = MultiplicationModel(self.model, self.model2) 
104        self.modelD = DiamCylFunc() 
105
106    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
107    def test_multplication_radius(self):
108        """
109            test multiplication model (check the effective radius & the output
110             of the multiplication)
111        """
112        self.model.setParam("radius", 60)
113        modelDrun = 60
114        self.model2.setParam("volfraction", 0.2)
115        self.model2.setParam("effect_radius", modelDrun )
116       
117        #Compare new method with old method         
118        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
119       
120        #Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
121        self.assertEqual(self.model.calculate_ER(), modelDrun)
122       
123       
124    def testMultiplicationParam(self):
125        """ Test Multiplication  (check the parameters)"""
126        ## test details dictionary
127
128        ## test parameters list
129        list3= self.model3.getParamList()
130
131        for item in self.model.getParamList():
132            if not 'scale' in item: 
133                self.assert_(item in list3)
134        for item in self.model2.getParamList():
135            #model3 parameters should not include effect_radius*
136            if not 'effect_radius' in item: 
137                self.assert_(item in list3)
138           
139        ## test set value for parameters and get paramaters
140        self.model3.setParam("scale_factor", 15)
141        self.assertEqual(self.model3.getParam("scale_factor"), 15)
142        self.model3.setParam("radius", 20)
143        self.assertEqual(self.model3.getParam("radius"), 20)
144        self.model3.setParam("radius.width", 15)
145        self.assertEqual(self.model3.getParam("radius.width"), 15)
146        self.model3.setParam("scale_factor", 15)
147        self.assertEqual(self.model3.getParam("scale_factor"), 15)
148        self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
149       
150        ## Dispersity
151        list3= self.model3.getDispParamList()
152        self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width'])
153       
154        from sans.models.dispersion_models import ArrayDispersion
155        disp_th = ArrayDispersion()
156       
157        values_th = numpy.zeros(100)
158        weights   = numpy.zeros(100)
159        for i in range(100):
160            values_th[i]=(math.pi/99.0*i)
161            weights[i]=(1.0)
162   
163        disp_th.set_weights(values_th, weights)
164       
165        self.model3.set_dispersion('radius', disp_th)
166       
167        val_1d = self.model3.run(math.sqrt(0.0002))
168        val_2d = self.model3.runXY([0.01,0.01]) 
169       
170        self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
171        model4= self.model3.clone()
172        self.assertEqual(model4.getParam("radius"), 20)
173class TestsphereSHS(unittest.TestCase):
174    """
175        Unit tests for SphereModel(Q) * StickyHSStructure(Q)
176    """
177    def setUp(self):
178        from sans.models.SphereModel import SphereModel
179        from sans.models.StickyHSStructure import StickyHSStructure
180        from sans.models.DiamCylFunc import DiamCylFunc
181        from sans.models.MultiplicationModel import MultiplicationModel
182
183        self.model = SphereModel()
184        self.model2 = StickyHSStructure()
185        self.model3 = MultiplicationModel(self.model, self.model2) 
186        self.modelD = DiamCylFunc() 
187
188    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
189    def test_multplication_radius(self):
190        """
191            test multiplication model (check the effective radius & the output
192             of the multiplication)
193        """
194        self.model.setParam("radius", 60)
195        modelDrun = 60
196        self.model2.setParam("volfraction", 0.2)
197        self.model2.setParam("effect_radius", modelDrun )
198       
199        #Compare new method with old method         
200        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
201       
202        #Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
203        self.assertEqual(self.model.calculate_ER(), modelDrun)
204       
205       
206    def testMultiplicationParam(self):
207        """ Test Multiplication  (check the parameters)"""
208        ## test details dictionary
209
210        ## test parameters list
211        list3= self.model3.getParamList()
212
213        for item in self.model.getParamList():
214            if not 'scale' in item: 
215                self.assert_(item in list3)
216        for item in self.model2.getParamList():
217            #model3 parameters should not include effect_radius*
218            if not 'effect_radius' in item: 
219                self.assert_(item in list3)
220           
221        ## test set value for parameters and get paramaters
222        self.model3.setParam("scale_factor", 15)
223        self.assertEqual(self.model3.getParam("scale_factor"), 15)
224        self.model3.setParam("radius", 20)
225        self.assertEqual(self.model3.getParam("radius"), 20)
226        self.model3.setParam("radius.width", 15)
227        self.assertEqual(self.model3.getParam("radius.width"), 15)
228        self.model3.setParam("scale_factor", 15)
229        self.assertEqual(self.model3.getParam("scale_factor"), 15)
230        self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
231       
232        ## Dispersity
233        list3= self.model3.getDispParamList()
234        self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width'])
235       
236        from sans.models.dispersion_models import ArrayDispersion
237        disp_th = ArrayDispersion()
238       
239        values_th = numpy.zeros(100)
240        weights   = numpy.zeros(100)
241        for i in range(100):
242            values_th[i]=(math.pi/99.0*i)
243            weights[i]=(1.0)
244   
245        disp_th.set_weights(values_th, weights)
246       
247        self.model3.set_dispersion('radius', disp_th)
248       
249        val_1d = self.model3.run(math.sqrt(0.0002))
250        val_2d = self.model3.runXY([0.01,0.01]) 
251       
252        self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
253        model4= self.model3.clone()
254        self.assertEqual(model4.getParam("radius"), 20)
255       
256class TestsphereHayterM(unittest.TestCase):
257    """
258        Unit tests for SphereModel(Q) * HayterMSAStructure(Q)
259    """
260    def setUp(self):
261        from sans.models.SphereModel import SphereModel
262        from sans.models.HayterMSAStructure import HayterMSAStructure
263        from sans.models.DiamCylFunc import DiamCylFunc
264        from sans.models.MultiplicationModel import MultiplicationModel
265
266        self.model = SphereModel()
267        self.model2 = HayterMSAStructure()
268        self.model3 = MultiplicationModel(self.model, self.model2) 
269        self.modelD = DiamCylFunc() 
270
271    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
272    def test_multplication_radius(self):
273        """
274            test multiplication model (check the effective radius & the output
275             of the multiplication)
276        """
277        self.model.setParam("radius", 60)
278        modelDrun = 60
279        self.model2.setParam("volfraction", 0.2)
280        self.model2.setParam("effect_radius", modelDrun )
281       
282        #Compare new method with old method         
283        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
284       
285        #Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
286        self.assertEqual(self.model.calculate_ER(), modelDrun)
287       
288       
289    def testMultiplicationParam(self):
290        """ Test Multiplication  (check the parameters)"""
291        ## test details dictionary
292
293        ## test parameters list
294        list3= self.model3.getParamList()
295
296        for item in self.model.getParamList():
297            if not 'scale' in item: 
298                self.assert_(item in list3)
299        for item in self.model2.getParamList():
300            #model3 parameters should not include effect_radius*
301            if not 'effect_radius' in item: 
302                self.assert_(item in list3)
303           
304        ## test set value for parameters and get paramaters
305        self.model3.setParam("scale_factor", 15)
306        self.assertEqual(self.model3.getParam("scale_factor"), 15)
307        self.model3.setParam("radius", 20)
308        self.assertEqual(self.model3.getParam("radius"), 20)
309        self.model3.setParam("radius.width", 15)
310        self.assertEqual(self.model3.getParam("radius.width"), 15)
311        self.model3.setParam("scale_factor", 15)
312        self.assertEqual(self.model3.getParam("scale_factor"), 15)
313        self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
314       
315        ## Dispersity
316        list3= self.model3.getDispParamList()
317        self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width'])
318       
319        from sans.models.dispersion_models import ArrayDispersion
320        disp_th = ArrayDispersion()
321       
322        values_th = numpy.zeros(100)
323        weights   = numpy.zeros(100)
324        for i in range(100):
325            values_th[i]=(math.pi/99.0*i)
326            weights[i]=(1.0)
327   
328        disp_th.set_weights(values_th, weights)
329       
330        self.model3.set_dispersion('radius', disp_th)
331       
332        val_1d = self.model3.run(math.sqrt(0.0002))
333        val_2d = self.model3.runXY([0.01,0.01]) 
334
335        self.assertTrue(math.fabs(val_1d-val_2d)/val_1d < 0.02)
336
337        model4= self.model3.clone()
338        self.assertEqual(model4.getParam("radius"), 20)     
339         
340### P*S with cylinder model
341class TestcylinderSuareW(unittest.TestCase):
342    """
343        Unit tests for CylinderModel(Q) * SquareWellStructure(Q)
344    """
345    def setUp(self):
346        from sans.models.CylinderModel import CylinderModel
347        from sans.models.SquareWellStructure import SquareWellStructure
348        from sans.models.DiamCylFunc import DiamCylFunc
349        from sans.models.MultiplicationModel import MultiplicationModel
350
351        self.model = CylinderModel()
352        self.model2 = SquareWellStructure()
353        self.model3 = MultiplicationModel(self.model, self.model2) 
354        self.modelD = DiamCylFunc() 
355
356    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
357    def test_multplication_radius(self):
358        """
359            test multiplication model (check the effective radius & the output
360             of the multiplication)
361        """
362        self.model.setParam("radius", 60)
363        self.modelD.setParam("radius", 60)
364        modelDrun = self.modelD.run(0.1)/2
365        self.model2.setParam("volfraction", 0.2)
366        self.model2.setParam("effect_radius", modelDrun)
367       
368        #Compare new method with old method         
369        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
370       
371        #Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
372        self.assertEqual(self.model.calculate_ER(), modelDrun)
373       
374       
375    def testMultiplicationParam(self):
376        """ Test Multiplication  (check the setparameters and the run & runXY w/ array dispersion)"""
377        ## test details dictionary
378
379        ## test parameters list
380        list3= self.model3.getParamList()
381
382        for item in self.model.getParamList():
383            if not 'scale' in item: 
384                self.assert_(item in list3)
385        for item in self.model2.getParamList():
386            #model3 parameters should not include effect_radius*
387            if not 'effect_radius' in item: 
388                self.assert_(item in list3)
389           
390        ## test set value for parameters and get paramaters
391        self.model3.setParam("scale_factor", 15)
392        self.assertEqual(self.model3.getParam("scale_factor"), 15)
393        self.model3.setParam("radius", 20)
394        self.assertEqual(self.model3.getParam("radius"), 20)
395        self.model3.setParam("radius.width", 15)
396        self.assertEqual(self.model3.getParam("radius.width"), 15)
397        self.model3.setParam("scale_factor", 15)
398        self.assertEqual(self.model3.getParam("scale_factor"), 15)
399        self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
400       
401        ## Dispersity
402        list3= self.model3.getDispParamList()
403        self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width', 'length.npts', \
404         'length.nsigmas', 'length.width', 'cyl_theta.npts', 'cyl_theta.nsigmas', 'cyl_theta.width',\
405          'cyl_phi.npts', 'cyl_phi.nsigmas', 'cyl_phi.width'])
406       
407        from sans.models.dispersion_models import ArrayDispersion
408        disp_th = ArrayDispersion()
409       
410        values_th = numpy.zeros(100)
411        weights   = numpy.zeros(100)
412        for i in range(100):
413            values_th[i]=(math.pi/99.0*i)
414            weights[i]=(1.0)
415   
416        disp_th.set_weights(values_th, weights)
417       
418        self.model3.set_dispersion('radius', disp_th)
419       
420        model4= self.model3.clone()
421        self.assertEqual(model4.getParam("radius"), 20)
422     
423class TestcylinderHardS(unittest.TestCase):
424    """
425        Unit tests for CylinderModel(Q) * HardsphereStructure(Q)
426    """
427    def setUp(self):
428        from sans.models.CylinderModel import CylinderModel
429        from sans.models.HardsphereStructure import HardsphereStructure
430        from sans.models.DiamCylFunc import DiamCylFunc
431        from sans.models.MultiplicationModel import MultiplicationModel
432
433        self.model = CylinderModel()
434        self.model2 = HardsphereStructure()
435        self.model3 = MultiplicationModel(self.model, self.model2) 
436        self.modelD = DiamCylFunc() 
437
438    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
439    def test_multplication_radius(self):
440        """
441            test multiplication model (check the effective radius & the output
442             of the multiplication)
443        """
444        self.model.setParam("radius", 60)
445        self.modelD.setParam("radius", 60)
446        modelDrun = self.modelD.run(0.1)/2
447        self.model2.setParam("volfraction", 0.2)
448        self.model2.setParam("effect_radius", modelDrun )
449       
450        #Compare new method with old method         
451        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
452       
453        #Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
454        self.assertEqual(self.model.calculate_ER(), modelDrun)
455       
456       
457    def testMultiplicationParam(self):
458        """ Test Multiplication """
459        ## test details dictionary
460
461        ## test parameters list
462        list3= self.model3.getParamList()
463
464        for item in self.model.getParamList():
465            #model3 parameters should not include scale*
466            if not 'scale' in item: 
467                self.assert_(item in list3)
468        for item in self.model2.getParamList():
469            #model3 parameters should not include effect_radius*
470            if not 'effect_radius' in item: 
471                self.assert_(item in list3)
472           
473        ## test set value for parameters and get paramaters
474        #self.model3.setParam("scale", 15)
475        #self.assertEqual(self.model3.getParam("scale"), 15)
476        self.model3.setParam("scale_factor", 0.1)
477        self.assertEqual(self.model3.getParam("scale_factor"), 0.1)
478        self.model3.setParam("radius", 20)
479        self.assertEqual(self.model3.getParam("radius"), 20)
480        self.model3.setParam("radius.width", 15)
481        self.assertEqual(self.model3.getParam("radius.width"), 15)
482        self.model3.setParam("scale_factor", 15)
483        self.assertEqual(self.model3.getParam("scale_factor"), 15)
484        self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
485       
486        ## Dispersity
487        list3= self.model3.getDispParamList()
488        self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width', 'length.npts', \
489         'length.nsigmas', 'length.width', 'cyl_theta.npts', 'cyl_theta.nsigmas', 'cyl_theta.width',\
490          'cyl_phi.npts', 'cyl_phi.nsigmas', 'cyl_phi.width'])
491       
492        from sans.models.dispersion_models import ArrayDispersion
493        disp_th = ArrayDispersion()
494       
495        values_th = numpy.zeros(100)
496        weights   = numpy.zeros(100)
497        for i in range(100):
498            values_th[i]=(math.pi/99.0*i)
499            weights[i]=(1.0)
500   
501        disp_th.set_weights(values_th, weights)
502       
503        self.model3.set_dispersion('radius', disp_th)
504       
505
506        model4= self.model3.clone()
507        self.assertEqual(model4.getParam("radius"), 20)
508class TestcylinderSHS(unittest.TestCase):
509    """
510        Unit tests for SphereModel(Q) * StickyHSStructure(Q)
511    """
512    def setUp(self):
513        from sans.models.CylinderModel import CylinderModel
514        from sans.models.StickyHSStructure import StickyHSStructure
515        from sans.models.DiamCylFunc import DiamCylFunc
516        from sans.models.MultiplicationModel import MultiplicationModel
517
518        self.model = CylinderModel()
519        self.model2 = StickyHSStructure()
520        self.model3 = MultiplicationModel(self.model, self.model2) 
521        self.modelD = DiamCylFunc()
522
523    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
524    def test_multplication_radius(self):
525        """
526            test multiplication model (check the effective radius & the output
527             of the multiplication)
528        """
529        self.model.setParam("radius", 60)
530        self.modelD.setParam("radius", 60)
531        modelDrun = self.modelD.run(0.1)/2
532        self.model2.setParam("volfraction", 0.2)
533        self.model2.setParam("effect_radius", modelDrun )
534       
535        #Compare new method with old method         
536        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
537       
538        #Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
539        self.assertEqual(self.model.calculate_ER(), modelDrun)
540       
541       
542    def testMultiplicationParam(self):
543        """ Test Multiplication  (check the parameters)"""
544        ## test details dictionary
545
546        ## test parameters list
547        list3= self.model3.getParamList()
548
549        for item in self.model.getParamList():
550            if not 'scale' in item: 
551                self.assert_(item in list3)
552        for item in self.model2.getParamList():
553            #model3 parameters should not include effect_radius*
554            if not 'effect_radius' in item: 
555                self.assert_(item in list3)
556           
557        ## test set value for parameters and get paramaters
558        self.model3.setParam("scale_factor", 15)
559        self.assertEqual(self.model3.getParam("scale_factor"), 15)
560        self.model3.setParam("radius", 20)
561        self.assertEqual(self.model3.getParam("radius"), 20)
562        self.model3.setParam("radius.width", 15)
563        self.assertEqual(self.model3.getParam("radius.width"), 15)
564        self.model3.setParam("scale_factor", 15)
565        self.assertEqual(self.model3.getParam("scale_factor"), 15)
566        self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
567       
568        ## Dispersity
569        list3= self.model3.getDispParamList()
570        self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width', 'length.npts', \
571         'length.nsigmas', 'length.width', 'cyl_theta.npts', 'cyl_theta.nsigmas', 'cyl_theta.width',\
572          'cyl_phi.npts', 'cyl_phi.nsigmas', 'cyl_phi.width'])
573       
574        from sans.models.dispersion_models import ArrayDispersion
575        disp_th = ArrayDispersion()
576       
577        values_th = numpy.zeros(100)
578        weights   = numpy.zeros(100)
579        for i in range(100):
580            values_th[i]=(math.pi/99.0*i)
581            weights[i]=(1.0)
582   
583        disp_th.set_weights(values_th, weights)
584       
585        self.model3.set_dispersion('radius', disp_th)
586       
587        model4= self.model3.clone()
588        self.assertEqual(model4.getParam("radius"), 20)
589       
590class TestcylinderHayterM(unittest.TestCase):
591    """
592        Unit tests for CylinderModel(Q) * HayterMSAStructure(Q)
593    """
594    def setUp(self):
595        from sans.models.CylinderModel import CylinderModel
596        from sans.models.HayterMSAStructure import HayterMSAStructure
597        from sans.models.DiamCylFunc import DiamCylFunc
598        from sans.models.MultiplicationModel import MultiplicationModel
599
600        self.model = CylinderModel()
601        self.model2 = HayterMSAStructure()
602        self.model3 = MultiplicationModel(self.model, self.model2) 
603        self.modelD = DiamCylFunc()
604
605    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
606    def test_multplication_radius(self):
607        """
608            test multiplication model (check the effective radius & the output
609             of the multiplication)
610        """
611        self.model.setParam("radius", 60)
612        self.modelD.setParam("radius", 60)
613        modelDrun = self.modelD.run(0.1)/2
614        self.model2.setParam("volfraction", 0.2)
615        self.model2.setParam("effect_radius", modelDrun )
616       
617        #Compare new method with old method         
618        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
619       
620        #Compare radius from two different calculations. Note: modelD.run(0.0) is DIAMETER
621        self.assertEqual(self.model.calculate_ER(), modelDrun)
622       
623       
624    def testMultiplicationParam(self):
625        """ Test Multiplication  (check the parameters)"""
626        ## test details dictionary
627
628        ## test parameters list
629        list3= self.model3.getParamList()
630
631        for item in self.model.getParamList():
632            if not 'scale' in item: 
633                self.assert_(item in list3)
634        for item in self.model2.getParamList():
635            #model3 parameters should not include effect_radius*
636            if not 'effect_radius' in item: 
637                self.assert_(item in list3)
638           
639        ## test set value for parameters and get paramaters
640        #self.model3.setParam("scale", 15)
641        #self.assertEqual(self.model3.getParam("scale"), 15)
642        self.model3.setParam("scale_factor", 15)
643        self.assertEqual(self.model3.getParam("scale_factor"), 15)
644        self.model3.setParam("radius", 20)
645        self.assertEqual(self.model3.getParam("radius"), 20)
646        self.model3.setParam("radius.width", 15)
647        self.assertEqual(self.model3.getParam("radius.width"), 15)
648        self.model3.setParam("scale_factor", 15)
649        self.assertEqual(self.model3.getParam("scale_factor"), 15)
650        self.assertEqual(self.model3.getParam("volfraction"), self.model.getParam("scale"))
651       
652        ## Dispersity
653        list3= self.model3.getDispParamList()
654        self.assertEqual(list3, ['radius.npts', 'radius.nsigmas', 'radius.width', 'length.npts', \
655         'length.nsigmas', 'length.width', 'cyl_theta.npts', 'cyl_theta.nsigmas', 'cyl_theta.width',\
656          'cyl_phi.npts', 'cyl_phi.nsigmas', 'cyl_phi.width'])
657       
658        from sans.models.dispersion_models import ArrayDispersion
659        disp_th = ArrayDispersion()
660       
661        values_th = numpy.zeros(100)
662        weights   = numpy.zeros(100)
663        for i in range(100):
664            values_th[i]=(math.pi/99.0*i)
665            weights[i]=(1.0)
666   
667        disp_th.set_weights(values_th, weights)
668       
669        self.model3.set_dispersion('radius', disp_th)       
670
671        model4= self.model3.clone()
672        self.assertEqual(model4.getParam("radius"), 20)       
673       
674class TestGuinierHayterM(unittest.TestCase):
675    """
676        Unit tests for GuinierModel(Q) * HayterMSAStructure(Q)
677    """
678    def setUp(self):
679        from sans.models.GuinierModel import GuinierModel
680        from sans.models.HayterMSAStructure import HayterMSAStructure
681        from sans.models.MultiplicationModel import MultiplicationModel
682
683        self.model = GuinierModel()
684        self.model2 = HayterMSAStructure()
685        self.model3 = MultiplicationModel(self.model, self.model2) 
686
687    #Radius of model1.calculate_ER should be equal to the output/2 of DiamFunctions
688    def test_multplication_radius(self):
689        """
690            test multiplication model (check the effective radius & the output
691             of the multiplication)
692        """
693        self.model.setParam("rg", 60)
694        self.model.setParam("scale", 1)
695        #Compare new method with old method         
696        self.assertEqual(self.model3.run(0.1), self.model.run(0.1)*self.model2.run(0.1))
697       
698        #effective radius calculation is not implemented for this model.
699        self.assertEqual(self.model3.calculate_ER(), NotImplemented)       
700       
701class TestLamellarHayterM(unittest.TestCase):
702    """
703        Unit tests for LamellarModel(Q) * HayterMSAStructure(Q)
704    """
705    def setUp(self):
706        from sans.models.LamellarModel import LamellarModel
707        from sans.models.HayterMSAStructure import HayterMSAStructure
708        from sans.models.MultiplicationModel import MultiplicationModel
709
710        self.model = LamellarModel()
711        self.model2 = HayterMSAStructure()
712        self.model3 = MultiplicationModel(self.model, self.model2) 
713
714    #Radius of model1.calculate_ER should Not be finite.
715    def test_multplication_radius(self):
716        """
717            test multiplication model (check the effective radius & the output
718             of the multiplication)
719        """
720        #Check run       
721        self.assertFalse(numpy.isfinite(self.model3.run(0.1)))
722        #check effective radius .
723        self.assertTrue(numpy.isfinite(self.model.calculate_ER()))     
724               
725if __name__ == '__main__':
726    unittest.main()
Note: See TracBrowser for help on using the repository browser.