source: sans/XOP_Dev/SANSAnalysis/lib/libTwoPhase.c @ 554

Last change on this file since 554 was 554, checked in by srkline, 13 years ago

(libTwoPhase):re-definition if DAB parameters so they are not correlated

(libSphere): correct integration ranges/normalization for simple cubic model

(elliptical cylinder): wholesale changes (JaeHie??). not really sure of these, but probably related to the definition of the relative orientation angles.

File size: 10.5 KB
Line 
1/*      TwoPhaseFit.c
2
3*/
4
5#include "StandardHeaders.h"                    // Include ANSI headers, Mac headers
6#include "libTwoPhase.h"
7
8// scattering from the Teubner-Strey model for microemulsions - hardly needs to be an XOP...
9double
10TeubnerStreyModel(double dp[], double q)
11{
12        double inten,q2,q4;             //my local names
13       
14        q2 = q*q;
15        q4 = q2*q2;
16       
17        inten = 1.0/(dp[0]+dp[1]*q2+dp[2]*q4);
18        inten += dp[3]; 
19        return(inten);
20}
21
22double
23Power_Law_Model(double dp[], double q)
24{
25        double qval;
26        double inten,A,m,bgd;           //my local names
27       
28        qval= q;
29       
30        A = dp[0];
31        m = dp[1];
32        bgd = dp[2];
33        inten = A*pow(qval,-m) + bgd;
34        return(inten);
35}
36
37
38double
39Peak_Lorentz_Model(double dp[], double q)
40{
41        double qval;
42        double inten,I0, qpk, dq,bgd;           //my local names
43        qval= q;
44       
45        I0 = dp[0];
46        qpk = dp[1];
47        dq = dp[2];
48        bgd = dp[3];
49        inten = I0/(1.0 + pow( (qval-qpk)/dq,2) ) + bgd;
50       
51        return(inten);
52}
53
54double
55Peak_Gauss_Model(double dp[], double q)
56{
57        double qval;
58        double inten,I0, qpk, dq,bgd;           //my local names
59       
60        qval= q;
61       
62        I0 = dp[0];
63        qpk = dp[1];
64        dq = dp[2];
65        bgd = dp[3];
66        inten = I0*exp(-0.5*pow((qval-qpk)/dq,2))+ bgd;
67       
68        return(inten);
69}
70
71double
72Lorentz_Model(double dp[], double q)
73{
74        double qval;
75        double inten,I0, L,bgd;         //my local names
76       
77        qval= q;
78       
79        I0 = dp[0];
80        L = dp[1];
81        bgd = dp[2];
82        inten = I0/(1.0 + (qval*L)*(qval*L)) + bgd;
83       
84        return(inten);
85}
86
87double
88Fractal(double dp[], double q)
89{
90        double x,pi;
91        double r0,Df,corr,phi,sldp,sldm,bkg;
92        double pq,sq,ans;
93       
94        pi = 4.0*atan(1.0);
95        x=q;
96       
97        phi = dp[0];            // volume fraction of building block spheres...
98        r0 = dp[1];             //  radius of building block
99        Df = dp[2];             //  fractal dimension
100        corr = dp[3];           //  correlation length of fractal-like aggregates
101        sldp = dp[4];           // SLD of building block
102        sldm = dp[5];           // SLD of matrix or solution
103        bkg = dp[6];            //  flat background
104       
105        //calculate P(q) for the spherical subunits, units cm-1 sr-1
106        pq = 1.0e8*phi*4.0/3.0*pi*r0*r0*r0*(sldp-sldm)*(sldp-sldm)*pow((3*(sin(x*r0) - x*r0*cos(x*r0))/pow((x*r0),3)),2);
107       
108        //calculate S(q)
109        sq = Df*exp(gammln(Df-1.0))*sin((Df-1.0)*atan(x*corr));
110        sq /= pow((x*r0),Df) * pow((1.0 + 1.0/(x*corr)/(x*corr)),((Df-1.0)/2.0));
111        sq += 1.0;
112        //combine and return
113        ans = pq*sq + bkg;
114       
115        return(ans);
116}
117
118// 6 JUL 2009 SRK changed definition of Izero scale factor to be uncorrelated with range
119//
120double
121DAB_Model(double dp[], double q)
122{
123        double qval,inten;
124        double Izero, range, incoh;
125       
126        qval= q;
127        Izero = dp[0];
128        range = dp[1];
129        incoh = dp[2]; 
130       
131        inten = (Izero*range*range*range)/pow((1.0 + (qval*range)*(qval*range)),2) + incoh;
132       
133        return(inten);
134}
135
136// G. Beaucage's Unified Model (1-4 levels)
137//
138double
139OneLevel(double dp[], double q)
140{
141        double x,ans,erf1;
142        double G1,Rg1,B1,Pow1,bkg,scale;
143       
144        x=q;
145        scale = dp[0];
146        G1 = dp[1];
147        Rg1 = dp[2];
148        B1 = dp[3];
149        Pow1 = dp[4];
150        bkg = dp[5];
151       
152        erf1 = erf( (x*Rg1/sqrt(6.0)));
153       
154        ans = G1*exp(-x*x*Rg1*Rg1/3.0);
155        ans += B1*pow((erf1*erf1*erf1/x),Pow1);
156       
157        ans *= scale;
158        ans += bkg;
159        return(ans);
160}
161
162// G. Beaucage's Unified Model (1-4 levels)
163//
164double
165TwoLevel(double dp[], double q)
166{
167        double x;
168        double ans,G1,Rg1,B1,G2,Rg2,B2,Pow1,Pow2,bkg;
169        double erf1,erf2,scale;
170       
171        x=q;
172       
173        scale = dp[0];
174        G1 = dp[1];     //equivalent to I(0)
175        Rg1 = dp[2];
176        B1 = dp[3];
177        Pow1 = dp[4];
178        G2 = dp[5];
179        Rg2 = dp[6];
180        B2 = dp[7];
181        Pow2 = dp[8];
182        bkg = dp[9];
183       
184        erf1 = erf( (x*Rg1/sqrt(6.0)) );
185        erf2 = erf( (x*Rg2/sqrt(6.0)) );
186        //Print erf1
187       
188        ans = G1*exp(-x*x*Rg1*Rg1/3.0);
189        ans += B1*exp(-x*x*Rg2*Rg2/3.0)*pow((erf1*erf1*erf1/x),Pow1);
190        ans += G2*exp(-x*x*Rg2*Rg2/3.0);
191        ans += B2*pow((erf2*erf2*erf2/x),Pow2);
192       
193        ans *= scale;
194        ans += bkg;
195       
196        return(ans);
197}
198
199// G. Beaucage's Unified Model (1-4 levels)
200//
201double
202ThreeLevel(double dp[], double q)
203{
204        double x;
205        double ans,G1,Rg1,B1,G2,Rg2,B2,Pow1,Pow2,bkg;
206        double G3,Rg3,B3,Pow3,erf3;
207        double erf1,erf2,scale;
208       
209        x=q;
210       
211        scale = dp[0];
212        G1 = dp[1];     //equivalent to I(0)
213        Rg1 = dp[2];
214        B1 = dp[3];
215        Pow1 = dp[4];
216        G2 = dp[5];
217        Rg2 = dp[6];
218        B2 = dp[7];
219        Pow2 = dp[8];
220        G3 = dp[9];
221        Rg3 = dp[10];
222        B3 = dp[11];
223        Pow3 = dp[12];
224        bkg = dp[13];
225       
226        erf1 = erf( (x*Rg1/sqrt(6.0)) );
227        erf2 = erf( (x*Rg2/sqrt(6.0)) );
228        erf3 = erf( (x*Rg3/sqrt(6.0)) );
229        //Print erf1
230       
231        ans = G1*exp(-x*x*Rg1*Rg1/3.0) + B1*exp(-x*x*Rg2*Rg2/3.0)*pow((erf1*erf1*erf1/x),Pow1);
232        ans += G2*exp(-x*x*Rg2*Rg2/3.0) + B2*exp(-x*x*Rg3*Rg3/3.0)*pow((erf2*erf2*erf2/x),Pow2);
233        ans += G3*exp(-x*x*Rg3*Rg3/3.0) + B3*pow((erf3*erf3*erf3/x),Pow3);
234       
235        ans *= scale;
236        ans += bkg;
237       
238        return(ans);
239}
240
241// G. Beaucage's Unified Model (1-4 levels)
242//
243double
244FourLevel(double dp[], double q)
245{
246        double x;
247        double ans,G1,Rg1,B1,G2,Rg2,B2,Pow1,Pow2,bkg;
248        double G3,Rg3,B3,Pow3,erf3;
249        double G4,Rg4,B4,Pow4,erf4;
250        double erf1,erf2,scale;
251       
252        x=q;
253       
254        scale = dp[0];
255        G1 = dp[1];     //equivalent to I(0)
256        Rg1 = dp[2];
257        B1 = dp[3];
258        Pow1 = dp[4];
259        G2 = dp[5];
260        Rg2 = dp[6];
261        B2 = dp[7];
262        Pow2 = dp[8];
263        G3 = dp[9];
264        Rg3 = dp[10];
265        B3 = dp[11];
266        Pow3 = dp[12];
267        G4 = dp[13];
268        Rg4 = dp[14];
269        B4 = dp[15];
270        Pow4 = dp[16];
271        bkg = dp[17];
272       
273        erf1 = erf( (x*Rg1/sqrt(6.0)) );
274        erf2 = erf( (x*Rg2/sqrt(6.0)) );
275        erf3 = erf( (x*Rg3/sqrt(6.0)) );
276        erf4 = erf( (x*Rg4/sqrt(6.0)) );
277       
278        ans = G1*exp(-x*x*Rg1*Rg1/3.0) + B1*exp(-x*x*Rg2*Rg2/3.0)*pow((erf1*erf1*erf1/x),Pow1);
279        ans += G2*exp(-x*x*Rg2*Rg2/3.0) + B2*exp(-x*x*Rg3*Rg3/3.0)*pow((erf2*erf2*erf2/x),Pow2);
280        ans += G3*exp(-x*x*Rg3*Rg3/3.0) + B3*exp(-x*x*Rg4*Rg4/3.0)*pow((erf3*erf3*erf3/x),Pow3);
281        ans += G4*exp(-x*x*Rg4*Rg4/3.0) + B4*pow((erf4*erf4*erf4/x),Pow4);
282       
283        ans *= scale;
284        ans += bkg;
285       
286    return(ans);
287}
288
289double
290BroadPeak(double dp[], double q)
291{
292        // variables are:                                                       
293        //[0] Porod term scaling
294        //[1] Porod exponent
295        //[2] Lorentzian term scaling
296        //[3] Lorentzian screening length [A]
297        //[4] peak location [1/A]
298        //[5] Lorentzian exponent
299        //[6] background
300       
301        double aa,nn,cc,LL,Qzero,mm,bgd,inten,qval;
302        qval= q;
303        aa = dp[0];
304        nn = dp[1];
305        cc = dp[2]; 
306        LL = dp[3]; 
307        Qzero = dp[4]; 
308        mm = dp[5]; 
309        bgd = dp[6]; 
310       
311        inten = aa/pow(qval,nn);
312        inten += cc/(1.0 + pow((fabs(qval-Qzero)*LL),mm) );
313        inten += bgd;
314       
315        return(inten);
316}
317
318double
319CorrLength(double dp[], double q)
320{
321        // variables are:                                                       
322        //[0] Porod term scaling
323        //[1] Porod exponent
324        //[2] Lorentzian term scaling
325        //[3] Lorentzian screening length [A]
326        //[4] Lorentzian exponent
327        //[5] background
328       
329        double aa,nn,cc,LL,mm,bgd,inten,qval;
330        qval= q;
331        aa = dp[0];
332        nn = dp[1];
333        cc = dp[2]; 
334        LL = dp[3]; 
335        mm = dp[4]; 
336        bgd = dp[5]; 
337       
338        inten = aa/pow(qval,nn);
339        inten += cc/(1.0 + pow((qval*LL),mm) );
340        inten += bgd;
341       
342        return(inten);
343}
344
345double
346TwoLorentzian(double dp[], double q)
347{
348        // variables are:                                                       
349        //[0] Lorentzian term scaling
350        //[1] Lorentzian screening length [A]
351        //[2] Lorentzian exponent
352        //[3] Lorentzian #2 term scaling
353        //[4] Lorentzian #2 screening length [A]
354        //[5] Lorentzian #2 exponent
355        //[6] background
356               
357        double aa,LL1,nn,cc,LL2,mm,bgd,inten,qval;
358        qval= q;
359        aa = dp[0];
360        LL1 = dp[1];
361        nn = dp[2]; 
362        cc = dp[3]; 
363        LL2 = dp[4]; 
364        mm = dp[5]; 
365        bgd= dp[6];
366       
367        inten = aa/(1.0 + pow((qval*LL1),nn) );
368        inten += cc/(1.0 + pow((qval*LL2),mm) );
369        inten += bgd;
370       
371        return(inten);
372}
373
374double
375TwoPowerLaw(double dp[], double q)
376{
377        //[0] Coefficient
378        //[1] (-) Power @ low Q
379        //[2] (-) Power @ high Q
380        //[3] crossover Q-value
381        //[4] incoherent background
382               
383        double A, m1,m2,qc,bgd,scale,inten,qval;
384        qval= q;
385        A = dp[0];
386        m1 = dp[1];
387        m2 = dp[2]; 
388        qc = dp[3]; 
389        bgd = dp[4]; 
390       
391        if(qval<=qc){
392                inten = A*pow(qval,-1.0*m1);
393        } else {
394                scale = A*pow(qc,-1.0*m1) / pow(qc,-1.0*m2);
395                inten = scale*pow(qval,-1.0*m2);
396        }
397       
398        inten += bgd;
399       
400        return(inten);
401}
402
403double
404PolyGaussCoil(double dp[], double x)
405{
406        //w[0] = scale
407        //w[1] = radius of gyration []
408        //w[2] = polydispersity, ratio of Mw/Mn
409        //w[3] = bkg [cm-1]
410               
411        double scale,bkg,Rg,uval,Mw_Mn,inten,xi;
412
413        scale = dp[0];
414        Rg = dp[1];
415        Mw_Mn = dp[2]; 
416        bkg = dp[3]; 
417       
418        uval = Mw_Mn - 1.0;
419        if(uval == 0) {
420                uval = 1e-6;            //avoid divide by zero error
421        }
422       
423        xi = Rg*Rg*x*x/(1.0+2.0*uval);
424       
425        if(xi < 1e-3) {
426                return(scale+bkg);              //limiting value
427        }
428       
429        inten = 2.0*(pow((1.0+uval*xi),(-1.0/uval))+xi-1.0);
430        inten /= (1.0+uval)*xi*xi;
431
432        inten *= scale;
433        //add in the background
434        inten += bkg;   
435        return(inten);
436}
437
438double
439GaussLorentzGel(double dp[], double x)
440{
441        //[0] Gaussian scale factor
442        //[1] Gaussian (static) screening length
443        //[2] Lorentzian (fluctuation) scale factor
444        //[3] Lorentzian screening length
445        //[4] incoherent background
446               
447        double Ig0,gg,Il0,ll,bgd,inten;
448
449        Ig0 = dp[0];
450        gg = dp[1];
451        Il0 = dp[2]; 
452        ll = dp[3];
453        bgd = dp[4]; 
454       
455        inten = Ig0*exp(-1.0*x*x*gg*gg/2.0) + Il0/(1 + (x*ll)*(x*ll)) + bgd;
456       
457        return(inten);
458}
459
460
461static double
462gammln(double xx) {
463       
464    double x,y,tmp,ser;
465    static double cof[6]={76.18009172947146,-86.50532032941677,
466                24.01409824083091,-1.231739572450155,
467                0.1208650973866179e-2,-0.5395239384953e-5};
468    int j;
469       
470    y=x=xx;
471    tmp=x+5.5;
472    tmp -= (x+0.5)*log(tmp);
473    ser=1.000000000190015;
474    for (j=0;j<=5;j++) ser += cof[j]/++y;
475    return -tmp+log(2.5066282746310005*ser/x);
476}
477
478double
479GaussianShell(double w[], double x)
480{
481        // variables are:                                                       
482        //[0] scale
483        //[1] radius ()
484        //[2] thick () (thickness parameter - this is the std. dev. of the Gaussian width of the shell)
485        //[3] polydispersity of the radius
486        //[4] sld shell (-2)
487        //[5] sld solvent
488        //[6] background (cm-1)
489       
490        double scale,rad,delrho,bkg,del,thick,pd,sig,pi;
491        double t1,t2,t3,t4,retval,exfact,vshell,vexcl,sldShell,sldSolvent;
492        scale = w[0];
493        rad = w[1];
494        thick = w[2];
495        pd = w[3];
496        sldShell = w[4];
497        sldSolvent = w[5];
498        bkg = w[6];
499       
500        delrho = w[4] - w[5];
501        sig = pd*rad;
502       
503        pi = 4.0*atan(1.0);
504       
505        ///APPROXIMATION (see eqn 4 - but not a bad approximation)
506        // del is the equivalent shell thickness with sharp boundaries, centered at mean radius
507        del = thick*sqrt(2.0*pi);
508       
509        // calculate the polydisperse shell volume and the excluded volume
510        vshell=4.0*pi/3.0*( pow((rad+del/2.0),3) - pow((rad-del/2.0),3) ) *(1.0+pd*pd);
511        vexcl=4.0*pi/3.0*( pow((rad+del/2.0),3) ) *(1.0+pd*pd);
512       
513        //intensity, eqn 9(a-d)
514        exfact = exp(-2.0*sig*sig*x*x);
515       
516        t1 = 0.5*x*x*thick*thick*thick*thick*(1.0+cos(2.0*x*rad)*exfact);
517        t2 = x*thick*thick*(rad*sin(2.0*x*rad) + 2.0*x*sig*sig*cos(2.0*x*rad))*exfact;
518        t3 = 0.5*rad*rad*(1.0-cos(2.0*x*rad)*exfact);
519        t4 = 0.5*sig*sig*(1.0+4.0*x*rad*sin(2.0*x*rad)*exfact+cos(2.0*x*rad)*(4.0*sig*sig*x*x-1.0)*exfact);
520       
521        retval = t1+t2+t3+t4;
522        retval *= exp(-1.0*x*x*thick*thick);
523        retval *= (del*del/x/x);
524        retval *= 16.0*pi*pi*delrho*delrho*scale;
525        retval *= 1.0e8;
526       
527        //NORMALIZED by the AVERAGE shell volume, since scale is the volume fraction of material
528//      retval /= vshell
529        retval /= vexcl;
530        //re-normalize by polydisperse sphere volume, Gaussian distribution
531        retval /= (1.0+3.0*pd*pd);
532       
533        retval += bkg;
534       
535        return(retval);
536}
537
538
Note: See TracBrowser for help on using the repository browser.