source: sasview/sansmodels/src/sans/models/test/utest_nonshape.py @ 829eee9

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 829eee9 was 829eee9, checked in by Gervaise Alina <gervyh@…>, 16 years ago

added 10 other models
BEPolyelectrolyte
DABModel
DebyeModel?
FractalModel?
GuinierModel?
LorentzModel?
PorodModel?
PowerLawModel?
TeubnerSteyModel?
UnifiedModel?
  • Property mode set to 100644
File size: 17.7 KB
Line 
1"""
2    Unit tests for non shape based model (Task 8.2.1)
3    These tests are part of the requirements
4"""
5
6import unittest, time, math
7from scipy.special import erf,gamma
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
16import scipy 
17class TestGuinier(unittest.TestCase):
18    """
19        Unit tests for Guinier function
20       
21        F(x) = exp[ [A] + [B]*Q**2 ]
22       
23        The model has two parameters: A and B
24    """
25    def _func(self, a, b, x):
26        return math.exp(a+b*x**2)
27   
28    def setUp(self):
29        from GuinierModel import GuinierModel
30        self.model= GuinierModel()
31       
32    def test1D(self):
33        self.model.setParam('A', 2.0)
34        self.model.setParam('B', 1.0)
35       
36        self.assertEqual(self.model.run(0.0), math.exp(2.0))
37        self.assertEqual(self.model.run(2.0), math.exp(2.0+1.0*(2.0)**2))
38       
39    def test2D(self):
40        self.model.setParam('A', 2.0)
41        self.model.setParam('B', 1.0)
42       
43        value = self._func(2.0, 1.0, 1.0)*self._func(2.0, 1.0, 2.0)
44        self.assertEqual(self.model.runXY([0.0,0.0]), math.exp(2.0)*math.exp(2.0))
45        self.assertEqual(self.model.runXY([1.0,2.0]), value)
46       
47    def test2Dphi(self):
48        self.model.setParam('A', 2.0)
49        self.model.setParam('B', 1.0)
50       
51        x = 1.0
52        y = 2.0
53        r = math.sqrt(x**2 + y**2)
54        phi = math.atan2(y, x)
55       
56        value = self._func(2.0, 1.0, x)*self._func(2.0, 1.0, y)
57       
58        #self.assertEqual(self.model.run([r, phi]), value)
59        self.assertAlmostEquals(self.model.run([r, phi]), value,1)
60       
61       
62class TestPorod(unittest.TestCase):
63    """
64        Unit tests for Porod function
65       
66        F(x) = exp[ [C]/Q**4 ]
67       
68        The model has one parameter: C
69    """
70    def _func(self, c, x):
71        return math.exp(c/(x*x*x*x))
72   
73    def setUp(self):
74        from PorodModel import PorodModel
75        self.model= PorodModel()
76        self.model.setParam('c', 2.0)       
77       
78    def test1D(self):
79        value = self._func(2.0, 3.0)
80        self.assertEqual(self.model.run(3.0), value)
81       
82    def test2D(self):
83        value = self._func(2.0, 1.0)*self._func(2.0, 2.0)
84        self.assertEqual(self.model.runXY([1.0,2.0]), value)
85       
86    def test2Dphi(self):
87        x = 1.0
88        y = 2.0
89        r = math.sqrt(x**2 + y**2)
90        phi = math.atan2(y, x)
91       
92        value = self._func(2.0, 1.0)*self._func(2.0, 2.0)
93        self.assertAlmostEquals(self.model.run([r, phi]), value,1)
94       
95class TestDebye(unittest.TestCase):
96    """
97        Unit tests for Debye function
98       
99        F(x) = 2( exp(-x)+x -1 )/x**2
100       
101        The model has three parameters:
102            Rg     =  radius of gyration
103            scale  =  scale factor
104            bkd    =  Constant background
105    """
106    def _func(self, Rg, scale, bkg, x):
107        y = (Rg * x)**2
108        return scale * (2*(math.exp(-y) + y -1)/y**2) + bkg
109   
110    def setUp(self):
111        from DebyeModel import DebyeModel
112        self.model= DebyeModel()
113        self.model.setParam('Rg', 50.0)   
114        self.model.setParam('scale',1.0) 
115        self.model.setParam('bkd',0.001)   
116       
117    def test1D(self):
118        value = self._func(50.0, 1.0, 0.001, 2.0)
119        self.assertEqual(self.model.run(2.0), value)
120       
121        #user enter zero as a value of x
122        self.assertEqual(self.model.run(0.0),False)
123       
124       
125    def test2D(self):
126        value = self._func(50.0, 1.0, 0.001, 1.0)*self._func(50.0, 1.0, 0.001, 2.0)
127        self.assertEqual(self.model.runXY([1.0,2.0]), value)
128       
129    def test2Dphi(self):
130        x = 1.0
131        y = 2.0
132        r = math.sqrt(x**2 + y**2)
133        phi = math.atan2(y, x)
134       
135        value = self._func(50.0, 1.0, 0.001, 1.0)*self._func(50.0, 1.0, 0.001, 2.0)
136        self.assertAlmostEquals(self.model.run([r, phi]), value,1)
137       
138       
139class TestLorentz(unittest.TestCase):
140    """
141        Unit tests for Lorentz function
142       
143         F(x) = scale/( 1 + (x*L)^2 ) + bkd
144       
145        The model has three parameters:
146            L     =  screen Length
147            scale  =  scale factor
148            bkd    =  incoherent background
149    """
150    def _func(self,scale,L,bkd,x):
151         return scale/( 1 + (x*L)**2 ) + bkd
152    def setUp(self):
153        from LorentzModel import LorentzModel
154        self.model= LorentzModel()
155       
156    def test1D(self):
157        self.model.setParam('scale', 100.0)
158        self.model.setParam('L', 50.0)
159        self.model.setParam('bkd', 1.0)
160       
161        self.assertEqual(self.model.run(0.0), 101.0)
162        self.assertEqual(self.model.run(2.0), self._func(100.0, 50.0, 1.0, 2.0))
163       
164    def test2D(self):
165        self.model.setParam('scale', 100.0)
166        self.model.setParam('L', 50.0)
167        self.model.setParam('bkd', 1.0)
168       
169        value = self._func(100.0, 50.0, 1.0, 1.0)*self._func(100.0, 50.0, 1.0, 2.0)   
170        self.assertEqual(self.model.runXY([1.0,2.0]), value)
171       
172    def test2Dphi(self):
173        self.model.setParam('scale', 100.0)
174        self.model.setParam('L', 50.0)
175        self.model.setParam('bkd', 1.0)
176       
177        x = 1.0
178        y = 2.0
179        r = math.sqrt(x**2 + y**2)
180        phi = math.atan2(y, x)
181       
182        value = self._func(100.0, 50.0, 1.0, x)*self._func(100.0, 50.0, 1.0, y)
183        self.assertAlmostEquals(self.model.run([r, phi]), value,1)
184       
185class TestDAB(unittest.TestCase):
186    """
187        Unit tests for DAB function
188       
189         F(x) = scale/( 1 + (x*L)^2 )^(2) + bkd
190       
191        The model has three parameters:
192            L      =  Correlation Length
193            scale  =  scale factor
194            bkd    =  incoherent background
195    """
196    def _func(self, a, b,c, x):
197        return a/(( 1 + ( x * b )**2 ))**2 + c
198   
199    def setUp(self):
200        from DABModel import DABModel
201        self.model= DABModel()
202       
203    def test1D(self):
204        self.model.setParam('scale', 10.0)
205        self.model.setParam('L', 40.0)
206        self.model.setParam('bkd', 0.0)
207       
208        self.assertEqual(self.model.run(0.0), 10.0)
209        self.assertEqual(self.model.run(2.0), self._func(10.0, 40.0, 0.0, 2.0))
210       
211    def test2D(self):
212        self.model.setParam('scale', 10.0)
213        self.model.setParam('L', 40.0)
214        self.model.setParam('bkd', 0.0)
215       
216        value = self._func(10.0, 40.0, 0.0, 1.0)*self._func(10.0, 40.0, 0.0, 2.0)   
217        self.assertEqual(self.model.runXY([1.0,2.0]), value)
218       
219    def test2Dphi(self):
220        self.model.setParam('scale', 10.0)
221        self.model.setParam('L', 40.0)
222        self.model.setParam('bkd', 0.0)
223       
224        x = 1.0
225        y = 2.0
226        r = math.sqrt(x**2 + y**2)
227        phi = math.atan2(y, x)
228       
229        value = self._func(10.0, 40.0, 0.0, x)*self._func(10.0, 40.0, 0.0, y)
230        self.assertAlmostEquals(self.model.run([r, phi]), value,1)
231       
232class TestPowerLaw(unittest.TestCase):
233    """
234        Unit tests for PowerLaw function
235
236        F(x) = scale* (x)^(m) + bkd
237       
238        The model has three parameters:
239            m     =  power
240            scale  =  scale factor
241            bkd    =  incoherent background
242    """
243    def _func(self, a, m,c, x):
244        return a*(x )**m + c
245   
246    def setUp(self):
247        from PowerLawModel import PowerLawModel
248        self.model= PowerLawModel()
249       
250    def test1D(self):
251        self.model.setParam('scale', math.exp(-6))
252        self.model.setParam('m', 4.0)
253        self.model.setParam('bkd', 1.0)
254       
255        self.assertEqual(self.model.run(0.0), 1.0)
256        self.assertEqual(self.model.run(2.0), self._func(math.exp(-6), 4.0, 1.0, 2.0))
257       
258    def test2D(self):
259        self.model.setParam('scale', math.exp(-6))
260        self.model.setParam('m', 4.0)
261        self.model.setParam('bkd', 1.0)
262       
263        value = self._func(math.exp(-6), 4.0, 1.0, 1.0)\
264        *self._func(math.exp(-6), 4.0, 1.0, 2.0)   
265       
266        self.assertEqual(self.model.runXY([1.0,2.0]), value)
267       
268    def test2Dphi(self):
269        self.model.setParam('scale', math.exp(-6))
270        self.model.setParam('m', 4.0)
271        self.model.setParam('bkd', 1.0)
272       
273        x = 1.0
274        y = 2.0
275        r = math.sqrt(x**2 + y**2)
276        phi = math.atan2(y, x)
277       
278        value = self._func(math.exp(-6), 4.0, 1.0, x)\
279        *self._func(math.exp(-6), 4.0, 1.0, y)
280        self.assertAlmostEquals(self.model.run([r, phi]), value,1)
281               
282class TestTeubnerStrey(unittest.TestCase):
283    """
284        Unit tests for PowerLaw function
285
286        F(x) = 1/( scale + c1*(x)^(2)+  c2*(x)^(4)) + bkd
287       
288        The model has Four parameters:
289            scale  =  scale factor
290            c1     =  constant
291            c2     =  constant
292            bkd    =  incoherent background
293    """
294    def _func(self, a,c1,c2,b, x):
295        return 1/( a + c1*(x)**(2)+  c2*(x)**(4)) + b
296   
297    def setUp(self):
298        from TeubnerStreyModel import TeubnerStreyModel
299        self.model= TeubnerStreyModel()
300       
301    def test1D(self):
302       
303        self.model.setParam('c1', -30.0) 
304        self.model.setParam('c2', 5000.0) 
305        self.model.setParam('scale', 0.1)
306        self.model.setParam('bkd', 0.1)
307        #self.assertEqual(1/(math.sqrt(4)), math.pow(4,-1/2))
308        self.assertEqual(self.model.TeubnerStreyLengths(),False )
309       
310        self.assertEqual(self.model.run(0.0), 10.1)
311        self.assertEqual(self.model.run(2.0), self._func(0.1,-30.0,5000.0,0.1,2.0))
312       
313    def test2D(self):
314        self.model.setParam('c1', -30.0) 
315        self.model.setParam('c2', 5000.0) 
316        self.model.setParam('scale', 0.1)
317        self.model.setParam('bkd', 0.1)
318        value = self._func(0.1,-30.0,5000.0,0.1, 1.0)\
319        *self._func(0.1,-30.0,5000.0,0.1, 2.0)   
320       
321        self.assertEqual(self.model.runXY([1.0,2.0]), value)
322       
323    def test2Dphi(self):
324        self.model.setParam('c1', -30.0) 
325        self.model.setParam('c2', 5000.0) 
326        self.model.setParam('scale', 0.1)
327        self.model.setParam('bkd', 0.1)
328       
329        x = 1.0
330        y = 2.0
331        r = math.sqrt(x**2 + y**2)
332        phi = math.atan2(y, x)
333       
334        value = self._func(0.1,-30.0,5000.0,0.1, x)\
335        *self._func(0.1,-30.0,5000.0,0.1, y)
336        self.assertAlmostEquals(self.model.run([r, phi]), value,1)
337       
338class TestBEPolyelectrolyte(unittest.TestCase):
339    """
340        Unit tests for  BEPolyelectrolyte function
341       
342        F(x) = K*1/(4*pi()*Lb*(alpha)^(2)*(q^(2)+k2)/(1+(r02)^(2))*(q^(2)+k2)\
343                       *(q^(2)-(12*h*C/b^(2)))
344       
345        The model has Eight parameters:
346            K        =  Constrast factor of the polymer
347            Lb       =  Bjerrum length
348            H        =  virial parameter
349            B        =  monomer length
350            Cs       =  Concentration of monovalent salt
351            alpha    =  ionazation degree
352            C        = polymer molar concentration
353            bkd      = background
354    """
355    def _func(self, K, Lb, H, B, Cs, alpha, C, bkd, r02, k2,  x):
356        return (K /( (4*math.pi *Lb*(alpha**2)*(x**2 +k2)) *( (1 +(r02**2))  \
357                    *((x**2) + k2)*((x**2) -(12 * H * C/(B**2))) )))+ bkd
358   
359    def setUp(self):
360        from BEPolyelectrolyte import BEPolyelectrolyte
361        self.model= BEPolyelectrolyte()
362       
363    def test1D(self):
364       
365        self.model.setParam('K', 10.0) 
366        self.model.setParam('Lb', 7.1) 
367        self.model.setParam('H', 12)
368        self.model.setParam('B', 10)
369        self.model.setParam('Cs',0.0) 
370        self.model.setParam('alpha', 0.05) 
371        self.model.setParam('C', 0.7)
372        self.model.setParam('bkd', 0.001)
373        K2 = 4 * math.pi * 7.1 * (2*0.0 + 0.05*0.7)
374        Ca = 0.7 * 6.022136 * math.exp(-4)
375        r02 =1/(0.05 * math.pow(Ca,0.5)*(10/math.pow((48* math.pi *7.1),0.5)))
376 
377       
378        self.assertEqual(self.model.run(0.0), self._func( 10.0, 7.1, 12,\
379                        10.0, 0.0,0.05,0.7,0.001, r02, K2,  0.0))
380        self.assertEqual(self.model.run(2.0),  self._func( 10.0, 7.1, 12,\
381                        10.0, 0.0,0.05,0.7,0.001, r02, K2,  2.0))
382       
383    def test2D(self):
384        self.model.setParam('K', 10.0) 
385        self.model.setParam('Lb', 7.1) 
386        self.model.setParam('H', 12)
387        self.model.setParam('B', 10)
388        self.model.setParam('Cs',0.0) 
389        self.model.setParam('alpha', 0.05) 
390        self.model.setParam('C', 0.7)
391        self.model.setParam('bkd', 0.001)
392        K2 = 4 * math.pi * 7.1 * (2*0.0 + 0.05*0.7)
393        Ca = 0.7 * 6.022136 * math.exp(-4)
394        r02 =1/(0.05 * math.pow(Ca,0.5)*(10/math.pow((48* math.pi *7.1),0.5)))
395 
396        value = self._func(10.0, 7.1, 12, 10.0, 0.0,0.05,0.7,0.001, r02, K2,  1.0)\
397        *self._func(10.0, 7.1, 12,10.0, 0.0,0.05,0.7,0.001, r02, K2, 2.0)   
398       
399        self.assertAlmostEquals(self.model.runXY([1.0,2.0]), value)
400       
401    def test2Dphi(self):
402        self.model.setParam('K', 10.0) 
403        self.model.setParam('Lb', 7.1) 
404        self.model.setParam('H', 12)
405        self.model.setParam('B', 10)
406        self.model.setParam('Cs',0.0) 
407        self.model.setParam('alpha', 0.05) 
408        self.model.setParam('C', 0.7)
409        self.model.setParam('bkd', 0.001)
410        K2 = 4 * math.pi * 7.1 * (2*0.0 + 0.05*0.7)
411        Ca = 0.7 * 6.022136 * math.exp(-4)
412        r02 =1/(0.05 * math.pow(Ca,0.5)*(10/math.pow((48* math.pi *7.1),0.5)))
413       
414        x = 1.0
415        y = 2.0
416        r = math.sqrt(x**2 + y**2)
417        phi = math.atan2(y, x)
418       
419        value = self._func(10.0, 7.1, 12, 10.0, 0.0,0.05,0.7,0.001, r02, K2,  x)\
420        *self._func(10.0, 7.1, 12, 10.0, 0.0,0.05,0.7,0.001, r02, K2, y)
421        self.assertAlmostEquals(self.model.run([r, phi]), value,1)
422       
423class TestFractalModel(unittest.TestCase):
424    """
425        Unit tests for  Number Density Fractal function   
426        F(x)= P(x)*S(x) + bkd
427        The model has Seven parameters:
428            scale   =  Volume fraction
429            Radius  =  Block radius
430            Fdim    =  Fractal dimension
431            L       =  correlation Length
432            SDLB    =  SDL block
433            SDLS    =  SDL solvent
434            bkd     =  background
435    """
436    def _func(self,p,s, bkd, x):
437        return p*s + bkd
438   
439    def setUp(self):
440        from FractalModel import FractalModel
441        self.model= FractalModel()
442       
443    def test1D(self):
444       
445        self.model.setParam('scale', 0.05) 
446        self.model.setParam('Radius',5) 
447        self.model.setParam('Fdim',2)
448        self.model.setParam('L', 100)
449        self.model.setParam('SDLB',2*math.exp(-6)) 
450        self.model.setParam('SDLS', 6.35*math.exp(-6)) 
451        self.model.setParam('bkd', 0.0)
452       
453        s= 1 + (math.sin((2 - 1) * math.atan(2.0*100))* 2 * gamma(2-1))\
454           /( math.pow( (2.0*5),2)*( 1 + 1/math.pow(((2.0**2)*(100**2)),(2-1)/2))) 
455        v= (4/3)*math.pi *math.pow(5, 3)
456        f= ( math.sin(2.0*5)-(2.0*5)*math.cos(2.0*5) )/(3*math.pow(2.0*5, 3))
457        p= 0.05 *(v**2)*(((2*math.exp(-6))-(6.35*math.exp(-6)))**2)*(f**2)
458       
459        self.assertEqual(self.model._scatterRanDom(2.0),p )
460        self.assertEqual(self.model._Block(2.0),s )
461        self.assertEqual(self.model.run(2.0),self._func(p,s ,0.0,2.0))
462       
463class TestUnifiedPowerLaw(unittest.TestCase):
464    """
465        Unit tests for Unified PowerLaw function
466
467        F(x) =  bkd + sum(G[i]*exp(-x**2 *Rg[i]**2 /3)) \
468          + [B[i]( erf(x*Rg[i]/math.sqrt(6)))** (3*p[i])]/x**p[i] )
469       
470    """
471 
472    def setUp(self):
473        from  UnifiedPowerLaw import  UnifiedPowerLawModel
474        self.model=  UnifiedPowerLawModel()
475       
476    def _func(self,level,B,Rg,G,Pow,bkd, x):
477        return bkd + (B * math.pow(erf(x *Rg/math.sqrt(6)),3 *Pow))/math.pow(x,Pow)
478   
479    def _Sum (self,level,x):
480        self.sum = 0
481        for i in xrange(level):
482            self.sum =self.sum +self.model.getParam('G'+str(i+1))*math.exp(-(x**2)*\
483                         (self.model.getParam('Rg'+str(i+1))**2)/3)
484        return self.sum
485   
486    def test1D(self):
487       
488
489        self.model.setParam('bkd', 0.0)
490        #setValueParam(self,level,Bvalue,Rgvalue,Gvalue,Pvalue)
491        self.model.setValueParam(1,2,1,2,5)
492        self.model.setValueParam(2,3,12,8,9)
493        self.model.setValueParam(3,0,2,3,2)
494        self.model.setValueParam(4,1,4,1,-1)
495        self.model.setValueParam(5,1,4,1,-2)
496       
497        self.assertEqual(self.model.getValue('P',1),5)
498        self.assertEqual(self.model.getValue('Rg',2),12)
499   
500        value1 = self._func(1,2,1,2,5,0.0,1.0)+self._Sum(5,1.0)
501        value2 = self._func(2,3,12,8,9,0.0,1.0)+self._Sum(5,1.0)
502        value3 = self._func(3,0,2,3,2,0.0,1.0)+self._Sum(5,1.0)
503        value4 = self._func(4,1,4,1,-1,0.0,1.0)+self._Sum(5,1.0)
504        value5 = self._func(5,1,4,1,-2,0.0,1.0)+self._Sum(5,1.0)
505        self.assertEqual(self.model.run(1,1.0), value1)
506        self.assertEqual(self.model.run(2,1.0), value2)
507        self.assertEqual(self.model.run(3,1.0), value3)
508        self.assertEqual(self.model.run(4,1.0), value4)
509        self.assertEqual(self.model.run(5,1.0), value5)
510       
511 
512       
513       
514if __name__ == '__main__':
515    unittest.main()
Note: See TracBrowser for help on using the repository browser.