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

Last change on this file since 97 was 97, checked in by ajj, 16 years ago

Now committing the code correctly - having relied on XCode's SVN interface which doesn't behave (quelle surprise).

I hope this isn't too screwed up.

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#pragma XOP_SET_STRUCT_PACKING                  // All structures are 2-byte-aligned.
8
9#include "XOPStandardHeaders.h"                 // Include ANSI headers, Mac headers, IgorXOP.h, XOP.h and XOPSupport.h
10#include "SANSAnalysis.h"
11#include "libStructureFactor.h"
12#include "StructureFactor.h"
13
14
15//Hard Sphere Structure Factor
16//
17int
18HardSphereStructX(FitParamsPtr p)
19{
20        double *dp;                             // Pointer to double precision wave data.
21        float *fp;                              // Pointer to single precision wave data.
22        double q;
23       
24        if (p->waveHandle == NIL) {
25                SetNaN64(&p->result);
26                return NON_EXISTENT_WAVE;
27        }
28       
29        q= p->x;
30       
31        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
32                case NT_FP32:
33                        fp= WaveData(p->waveHandle);
34                        SetNaN64(&p->result);
35                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                   
36                case NT_FP64:
37                        dp= WaveData(p->waveHandle);
38                        p->result = HardSphereStruct(dp,q);
39                        return 0;
40                default:                                                                // We can't handle this wave data type.
41                        SetNaN64(&p->result);
42                        return REQUIRES_SP_OR_DP_WAVE;
43        }
44        return 0;
45}
46
47//Sticky Hard Sphere Structure Factor
48//
49int
50StickyHS_StructX(FitParamsPtr p)
51{
52        double *dp;                             // Pointer to double precision wave data.
53        float *fp;                              // Pointer to single precision wave data.
54        double q;
55       
56        if (p->waveHandle == NIL) {
57                SetNaN64(&p->result);
58                return NON_EXISTENT_WAVE;
59        }
60       
61        q= p->x;
62       
63        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
64                case NT_FP32:
65                        fp= WaveData(p->waveHandle);
66                        SetNaN64(&p->result);
67                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                   
68                case NT_FP64:
69                        dp= WaveData(p->waveHandle);
70                        p->result = StickyHS_Struct(dp,q);
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                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                   
105                case NT_FP64:
106                        dp= WaveData(p->waveHandle);
107                        p->result = SquareWellStruct(dp,q);
108                default:                                                                // We can't handle this wave data type.
109                        SetNaN64(&p->result);
110                        return REQUIRES_SP_OR_DP_WAVE;
111        }
112       
113        return 0;
114}
115
116// Hayter-Penfold (rescaled) MSA structure factor for screened Coulomb interactions
117//
118int
119HayterPenfoldMSAX(FitParamsPtr p)
120{
121        double *dp;                             // Pointer to double precision wave data.
122        float *fp;                              // Pointer to single precision wave data.
123        double q;
124       
125        if (p->waveHandle == NIL) {
126                SetNaN64(&p->result);
127                return NON_EXISTENT_WAVE;
128        }
129       
130        q= p->x;
131       
132        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
133                case NT_FP32:
134                        fp= WaveData(p->waveHandle);
135                        SetNaN64(&p->result);
136                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                   
137                case NT_FP64:
138                        dp= WaveData(p->waveHandle);
139                        p->result = HayterPenfoldMSA(dp,q);
140                        return 0;
141                default:                                                                // We can't handle this wave data type.
142                        SetNaN64(&p->result);
143                        return REQUIRES_SP_OR_DP_WAVE;
144        }
145       
146        return 0;
147}
148
149
150// called as DiamCylX(hcyl,rcyl)
151int
152DiamCylX(DiamParamsPtr p)
153{
154        double hcyl,rcyl;
155       
156        hcyl = p->p1;
157        rcyl = p->p2;
158   
159        p->result = DiamCyl(hcyl,rcyl);
160       
161        return(0);
162}
163
164//prolate OR oblate ellipsoids
165//aa is the axis of rotation
166//if aa>bb, then PROLATE
167//if aa<bb, then OBLATE
168// A. Isihara, J. Chem. Phys. 18, 1446 (1950)
169//returns DIAMETER
170// called as DiamEllipX(aa,bb)
171int
172DiamEllipX(DiamParamsPtr p)
173{
174       
175        double aa,bb;
176       
177        aa = p->p1;
178        bb = p->p2;
179       
180        p->result = DiamEllip(aa,bb);
181       
182        return(0);
183}
184
185
186#pragma XOP_RESET_STRUCT_PACKING                        // All structures are 2-byte-aligned.
187
188///////////end of XOP
189
190
Note: See TracBrowser for help on using the repository browser.