source: sans/Analysis/branches/ajj_23APR07/XOPs/SANSAnalysis/XOP/StructureFactor.c @ 188

Last change on this file since 188 was 188, checked in by srkline, 15 years ago

removed depricated #pragma statement for structure alignment and replaced with proper includes as directed by WM.

Mac resource file has additional threadsafe declarations

File size: 4.5 KB
Line 
1/*      SimpleFit.c
2
3A simplified project designed to act as a template for your curve fitting function.
4The fitting function is a simple polynomial. It works but is of no practical use.
5*/
6
7
8#include "XOPStandardHeaders.h"                 // Include ANSI headers, Mac headers, IgorXOP.h, XOP.h and XOPSupport.h
9#include "SANSAnalysis.h"
10#include "libSANSAnalysis.h"
11#include "StructureFactor.h"
12
13
14//Hard Sphere Structure Factor
15//
16int
17HardSphereStructX(FitParamsPtr p)
18{
19        double *dp;                             // Pointer to double precision wave data.
20        float *fp;                              // Pointer to single precision wave data.
21        double q;
22       
23        if (p->waveHandle == NIL) {
24                SetNaN64(&p->result);
25                return NON_EXISTENT_WAVE;
26        }
27       
28        q= p->x;
29       
30        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
31                case NT_FP32:
32                        fp= WaveData(p->waveHandle);
33                        SetNaN64(&p->result);
34                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                   
35                case NT_FP64:
36                        dp= WaveData(p->waveHandle);
37                        p->result = HardSphereStruct(dp,q);
38                        return 0;
39                default:                                                                // We can't handle this wave data type.
40                        SetNaN64(&p->result);
41                        return REQUIRES_SP_OR_DP_WAVE;
42        }
43        return 0;
44}
45
46//Sticky Hard Sphere Structure Factor
47//
48int
49StickyHS_StructX(FitParamsPtr p)
50{
51        double *dp;                             // Pointer to double precision wave data.
52        float *fp;                              // Pointer to single precision wave data.
53        double q;
54       
55        if (p->waveHandle == NIL) {
56                SetNaN64(&p->result);
57                return NON_EXISTENT_WAVE;
58        }
59       
60        q= p->x;
61       
62        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
63                case NT_FP32:
64                        fp= WaveData(p->waveHandle);
65                        SetNaN64(&p->result);
66                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                   
67                case NT_FP64:
68                        dp= WaveData(p->waveHandle);
69                        p->result = StickyHS_Struct(dp,q);
70                        return 0;
71                default:                                                                // We can't handle this wave data type.
72                        SetNaN64(&p->result);
73                        return REQUIRES_SP_OR_DP_WAVE;
74        }
75        return 0;
76}
77
78
79
80//     SUBROUTINE SQWELL: CALCULATES THE STRUCTURE FACTOR FOR A
81//                        DISPERSION OF MONODISPERSE HARD SPHERES
82//     IN THE Mean Spherical APPROXIMATION ASSUMING THE SPHERES
83//     INTERACT THROUGH A SQUARE WELL POTENTIAL.
84//** not the best choice of closure ** see note below
85//     REFS:  SHARMA,SHARMA, PHYSICA 89A,(1977),212
86int
87SquareWellStructX(FitParamsPtr p)
88{
89        double *dp;                             // Pointer to double precision wave data.
90        float *fp;                              // Pointer to single precision wave data.
91        double q;
92       
93        if (p->waveHandle == NIL) {
94                SetNaN64(&p->result);
95                return NON_EXISTENT_WAVE;
96        }
97       
98        q= p->x;
99       
100        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
101                case NT_FP32:
102                        fp= WaveData(p->waveHandle);
103                        SetNaN64(&p->result);
104                        XOPNotice("I think it's single precision\r");
105                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                   
106                case NT_FP64:
107                        dp= WaveData(p->waveHandle);
108                        p->result = SquareWellStruct(dp,q);
109                        return 0;
110                default:                                                                // We can't handle this wave data type.
111                        SetNaN64(&p->result);
112                        XOPNotice("I don't know what it is\r");
113                        return REQUIRES_SP_OR_DP_WAVE;
114        }
115       
116        return 0;
117}
118
119// Hayter-Penfold (rescaled) MSA structure factor for screened Coulomb interactions
120//
121int
122HayterPenfoldMSAX(FitParamsPtr p)
123{
124        double *dp;                             // Pointer to double precision wave data.
125        float *fp;                              // Pointer to single precision wave data.
126        double q;
127       
128        if (p->waveHandle == NIL) {
129                SetNaN64(&p->result);
130                return NON_EXISTENT_WAVE;
131        }
132       
133        q= p->x;
134       
135        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
136                case NT_FP32:
137                        fp= WaveData(p->waveHandle);
138                        SetNaN64(&p->result);
139                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                   
140                case NT_FP64:
141                        dp= WaveData(p->waveHandle);
142                        p->result = HayterPenfoldMSA(dp,q);
143                        return 0;
144                default:                                                                // We can't handle this wave data type.
145                        SetNaN64(&p->result);
146                        return REQUIRES_SP_OR_DP_WAVE;
147        }
148       
149        return 0;
150}
151
152
153// called as DiamCylX(hcyl,rcyl)
154int
155DiamCylX(DiamParamsPtr p)
156{
157        double hcyl,rcyl;
158       
159        hcyl = p->p1;
160        rcyl = p->p2;
161   
162        p->result = DiamCyl(hcyl,rcyl);
163       
164        return(0);
165}
166
167//prolate OR oblate ellipsoids
168//aa is the axis of rotation
169//if aa>bb, then PROLATE
170//if aa<bb, then OBLATE
171// A. Isihara, J. Chem. Phys. 18, 1446 (1950)
172//returns DIAMETER
173// called as DiamEllipX(aa,bb)
174int
175DiamEllipX(DiamParamsPtr p)
176{
177       
178        double aa,bb;
179       
180        aa = p->p1;
181        bb = p->p2;
182       
183        p->result = DiamEllip(aa,bb);
184       
185        return(0);
186}
187
188
189///////////end of XOP
190
191
Note: See TracBrowser for help on using the repository browser.