Context Navigation

source: sans/XOP_Dev/SANSAnalysis/XOP/TwoPhase.c @ 756

Last change on this file since 756 was 452, checked in by srkline, 14 years ago

Changes to the XOP code to use the newly added functions (2008 models).

XOPs have been verified against the Igor version of the code.

File size: 13.9 KB

Line
1	/* TwoPhaseFit.c
2
3	*/
4
5
6	#include "XOPStandardHeaders.h" // Include ANSI headers, Mac headers, IgorXOP.h, XOP.h and XOPSupport.h
7	#include "SANSAnalysis.h"
8	#include "libSANSAnalysis.h"
9	#include "TwoPhase.h"
10
11	// scattering from the Teubner-Strey model for microemulsions - hardly needs to be an XOP...
12	int
13	TeubnerStreyModelX(FitParamsPtr p)
14	{
15	double *dp; // Pointer to double precision wave data.
16	float *fp; // Pointer to single precision wave data.
17	double q;
18
19	if (p->waveHandle == NIL) {
20	SetNaN64(&p->result);
21	return NON_EXISTENT_WAVE;
22	}
23
24	q = p->x;
25
26	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
27	case NT_FP32:
28	fp= WaveData(p->waveHandle);
29	SetNaN64(&p->result);
30	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
31	case NT_FP64:
32	dp= WaveData(p->waveHandle);
33	p->result = TeubnerStreyModel(dp,q);
34	return 0;
35	default: // We can't handle this wave data type.
36	SetNaN64(&p->result);
37	return REQUIRES_SP_OR_DP_WAVE;
38	}
39
40	return 0;
41	}
42
43	int
44	Power_Law_ModelX(FitParamsPtr p)
45	{
46	double *dp; // Pointer to double precision wave data.
47	float *fp; // Pointer to single precision wave data.
48	double q;
49
50	if (p->waveHandle == NIL) {
51	SetNaN64(&p->result);
52	return NON_EXISTENT_WAVE;
53	}
54
55	q= p->x;
56
57	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
58	case NT_FP32:
59	fp= WaveData(p->waveHandle);
60	SetNaN64(&p->result);
61	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
62	case NT_FP64:
63	dp= WaveData(p->waveHandle);
64	p->result = Power_Law_Model(dp,q);
65	return 0;
66	default: // We can't handle this wave data type.
67	SetNaN64(&p->result);
68	return REQUIRES_SP_OR_DP_WAVE;
69	}
70
71	return 0;
72	}
73
74
75	int
76	Peak_Lorentz_ModelX(FitParamsPtr p)
77	{
78	double *dp; // Pointer to double precision wave data.
79	float *fp; // Pointer to single precision wave data.
80	double q;
81
82	if (p->waveHandle == NIL) {
83	SetNaN64(&p->result);
84	return NON_EXISTENT_WAVE;
85	}
86
87	q= p->x;
88
89	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
90	case NT_FP32:
91	fp= WaveData(p->waveHandle);
92	SetNaN64(&p->result);
93	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
94	case NT_FP64:
95	dp= WaveData(p->waveHandle);
96	p->result = Peak_Lorentz_Model(dp,q);
97	return 0;
98	default: // We can't handle this wave data type.
99	SetNaN64(&p->result);
100	return REQUIRES_SP_OR_DP_WAVE;
101	}
102
103	return 0;
104	}
105
106	int
107	Peak_Gauss_ModelX(FitParamsPtr p)
108	{
109	double *dp; // Pointer to double precision wave data.
110	float *fp; // Pointer to single precision wave data.
111	double q;
112
113	if (p->waveHandle == NIL) {
114	SetNaN64(&p->result);
115	return NON_EXISTENT_WAVE;
116	}
117
118	q= p->x;
119
120	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
121	case NT_FP32:
122	fp= WaveData(p->waveHandle);
123	SetNaN64(&p->result);
124	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
125	case NT_FP64:
126	dp= WaveData(p->waveHandle);
127	p->result = Peak_Gauss_Model(dp,q);
128	return 0;
129	default: // We can't handle this wave data type.
130	SetNaN64(&p->result);
131	return REQUIRES_SP_OR_DP_WAVE;
132	}
133
134	return 0;
135	}
136
137	int
138	Lorentz_ModelX(FitParamsPtr p)
139	{
140	double *dp; // Pointer to double precision wave data.
141	float *fp; // Pointer to single precision wave data.
142	double q;
143
144	if (p->waveHandle == NIL) {
145	SetNaN64(&p->result);
146	return NON_EXISTENT_WAVE;
147	}
148
149	q= p->x;
150
151	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
152	case NT_FP32:
153	fp= WaveData(p->waveHandle);
154	SetNaN64(&p->result);
155	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
156	case NT_FP64:
157	dp= WaveData(p->waveHandle);
158	p->result=Lorentz_Model(dp,q);
159	return 0;
160	default: // We can't handle this wave data type.
161	SetNaN64(&p->result);
162	return REQUIRES_SP_OR_DP_WAVE;
163	}
164
165	return 0;
166	}
167
168	int
169	FractalX(FitParamsPtr p)
170	{
171	double *dp; // Pointer to double precision wave data.
172	float *fp; // Pointer to single precision wave data.
173	double q;
174
175	if (p->waveHandle == NIL) {
176	SetNaN64(&p->result);
177	return NON_EXISTENT_WAVE;
178	}
179
180	q= p->x;
181
182	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
183	case NT_FP32:
184	fp= WaveData(p->waveHandle);
185	SetNaN64(&p->result);
186	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
187	case NT_FP64:
188	dp= WaveData(p->waveHandle);
189	p->result = Fractal(dp,q);
190	return 0;
191	default: // We can't handle this wave data type.
192	SetNaN64(&p->result);
193	return REQUIRES_SP_OR_DP_WAVE;
194	}
195
196	return 0;
197	}
198
199	int
200	DAB_ModelX(FitParamsPtr p)
201	{
202	double *dp; // Pointer to double precision wave data.
203	float *fp; // Pointer to single precision wave data.
204	double q;
205
206	if (p->waveHandle == NIL) {
207	SetNaN64(&p->result);
208	return NON_EXISTENT_WAVE;
209	}
210
211	q= p->x;
212
213	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
214	case NT_FP32:
215	fp= WaveData(p->waveHandle);
216	SetNaN64(&p->result);
217	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
218	case NT_FP64:
219	dp= WaveData(p->waveHandle);
220	p->result = DAB_Model(dp,q);
221	return 0;
222	default: // We can't handle this wave data type.
223	SetNaN64(&p->result);
224	return REQUIRES_SP_OR_DP_WAVE;
225	}
226
227	return 0;
228	}
229
230	// G. Beaucage's Unified Model (1-4 levels)
231	//
232	int
233	OneLevelX(FitParamsPtr p)
234	{
235	double *dp; // Pointer to double precision wave data.
236	float *fp; // Pointer to single precision wave data.
237	double q;
238
239	if (p->waveHandle == NIL) {
240	SetNaN64(&p->result);
241	return NON_EXISTENT_WAVE;
242	}
243
244	q= p->x;
245
246	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
247	case NT_FP32:
248	fp= WaveData(p->waveHandle);
249	SetNaN64(&p->result);
250	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
251	case NT_FP64:
252	dp= WaveData(p->waveHandle);
253	p-> result = OneLevel(dp,q);
254	return 0;
255	default: // We can't handle this wave data type.
256	SetNaN64(&p->result);
257	return REQUIRES_SP_OR_DP_WAVE;
258	}
259
260	return 0;
261	}
262
263	// G. Beaucage's Unified Model (1-4 levels)
264	//
265	int
266	TwoLevelX(FitParamsPtr p)
267	{
268	double *dp; // Pointer to double precision wave data.
269	float *fp; // Pointer to single precision wave data.
270	double q;
271
272	if (p->waveHandle == NIL) {
273	SetNaN64(&p->result);
274	return NON_EXISTENT_WAVE;
275	}
276
277	q= p->x;
278
279	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
280	case NT_FP32:
281	fp= WaveData(p->waveHandle);
282	SetNaN64(&p->result);
283	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
284	case NT_FP64:
285	dp= WaveData(p->waveHandle);
286	p->result = TwoLevel(dp, q);
287	return 0;
288	default: // We can't handle this wave data type.
289	SetNaN64(&p->result);
290	return REQUIRES_SP_OR_DP_WAVE;
291	}
292
293	return 0;
294	}
295
296	// G. Beaucage's Unified Model (1-4 levels)
297	//
298	int
299	ThreeLevelX(FitParamsPtr p)
300	{
301	double *dp; // Pointer to double precision wave data.
302	float *fp; // Pointer to single precision wave data.
303	double q;
304
305	if (p->waveHandle == NIL) {
306	SetNaN64(&p->result);
307	return NON_EXISTENT_WAVE;
308	}
309
310	q= p->x;
311
312	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
313	case NT_FP32:
314	fp= WaveData(p->waveHandle);
315	SetNaN64(&p->result);
316	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
317	case NT_FP64:
318	dp= WaveData(p->waveHandle);
319	p->result = ThreeLevel(dp, q);
320	return 0;
321	default: // We can't handle this wave data type.
322	SetNaN64(&p->result);
323	return REQUIRES_SP_OR_DP_WAVE;
324	}
325
326	return 0;
327	}
328
329	// G. Beaucage's Unified Model (1-4 levels)
330	//
331	int
332	FourLevelX(FitParamsPtr p)
333	{
334	double *dp; // Pointer to double precision wave data.
335	float *fp; // Pointer to single precision wave data.
336	double q;
337
338	if (p->waveHandle == NIL) {
339	SetNaN64(&p->result);
340	return NON_EXISTENT_WAVE;
341	}
342
343	q= p->x;
344
345	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
346	case NT_FP32:
347	fp= WaveData(p->waveHandle);
348	SetNaN64(&p->result);
349	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
350	case NT_FP64:
351	dp= WaveData(p->waveHandle);
352	p->result = FourLevel(dp,q);
353	return 0;
354	default: // We can't handle this wave data type.
355	SetNaN64(&p->result);
356	return REQUIRES_SP_OR_DP_WAVE;
357	}
358
359	return 0;
360	}
361
362	int
363	BroadPeakX(FitParamsPtr p)
364	{
365	double *dp; // Pointer to double precision wave data.
366	float *fp; // Pointer to single precision wave data.
367	double q;
368
369	if (p->waveHandle == NIL) {
370	SetNaN64(&p->result);
371	return NON_EXISTENT_WAVE;
372	}
373
374	q= p->x;
375
376	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
377	case NT_FP32:
378	fp= WaveData(p->waveHandle);
379	SetNaN64(&p->result);
380	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
381	case NT_FP64:
382	dp= WaveData(p->waveHandle);
383	p->result = BroadPeak(dp,q);
384	return 0;
385	default: // We can't handle this wave data type.
386	SetNaN64(&p->result);
387	return REQUIRES_SP_OR_DP_WAVE;
388	}
389
390	return 0;
391	}
392
393	int
394	CorrLengthX(FitParamsPtr p)
395	{
396	double *dp; // Pointer to double precision wave data.
397	float *fp; // Pointer to single precision wave data.
398	double q;
399
400	if (p->waveHandle == NIL) {
401	SetNaN64(&p->result);
402	return NON_EXISTENT_WAVE;
403	}
404
405	q= p->x;
406
407	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
408	case NT_FP32:
409	fp= WaveData(p->waveHandle);
410	SetNaN64(&p->result);
411	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
412	case NT_FP64:
413	dp= WaveData(p->waveHandle);
414	p->result = CorrLength(dp,q);
415	return 0;
416	default: // We can't handle this wave data type.
417	SetNaN64(&p->result);
418	return REQUIRES_SP_OR_DP_WAVE;
419	}
420
421	return 0;
422	}
423
424	int
425	TwoLorentzianX(FitParamsPtr p)
426	{
427	double *dp; // Pointer to double precision wave data.
428	float *fp; // Pointer to single precision wave data.
429	double q;
430
431	if (p->waveHandle == NIL) {
432	SetNaN64(&p->result);
433	return NON_EXISTENT_WAVE;
434	}
435
436	q= p->x;
437
438	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
439	case NT_FP32:
440	fp= WaveData(p->waveHandle);
441	SetNaN64(&p->result);
442	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
443	case NT_FP64:
444	dp= WaveData(p->waveHandle);
445	p->result = TwoLorentzian(dp,q);
446	return 0;
447	default: // We can't handle this wave data type.
448	SetNaN64(&p->result);
449	return REQUIRES_SP_OR_DP_WAVE;
450	}
451
452	return 0;
453	}
454
455	int
456	TwoPowerLawX(FitParamsPtr p)
457	{
458	double *dp; // Pointer to double precision wave data.
459	float *fp; // Pointer to single precision wave data.
460	double q;
461
462	if (p->waveHandle == NIL) {
463	SetNaN64(&p->result);
464	return NON_EXISTENT_WAVE;
465	}
466
467	q= p->x;
468
469	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
470	case NT_FP32:
471	fp= WaveData(p->waveHandle);
472	SetNaN64(&p->result);
473	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
474	case NT_FP64:
475	dp= WaveData(p->waveHandle);
476	p->result = TwoPowerLaw(dp,q);
477	return 0;
478	default: // We can't handle this wave data type.
479	SetNaN64(&p->result);
480	return REQUIRES_SP_OR_DP_WAVE;
481	}
482
483	return 0;
484	}
485
486	int
487	PolyGaussCoilX(FitParamsPtr p)
488	{
489	double *dp; // Pointer to double precision wave data.
490	float *fp; // Pointer to single precision wave data.
491	double q;
492
493	if (p->waveHandle == NIL) {
494	SetNaN64(&p->result);
495	return NON_EXISTENT_WAVE;
496	}
497
498	q= p->x;
499
500	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
501	case NT_FP32:
502	fp= WaveData(p->waveHandle);
503	SetNaN64(&p->result);
504	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
505	case NT_FP64:
506	dp= WaveData(p->waveHandle);
507	p->result = PolyGaussCoil(dp,q);
508	return 0;
509	default: // We can't handle this wave data type.
510	SetNaN64(&p->result);
511	return REQUIRES_SP_OR_DP_WAVE;
512	}
513
514	return 0;
515	}
516
517	int
518	GaussLorentzGelX(FitParamsPtr p)
519	{
520	double *dp; // Pointer to double precision wave data.
521	float *fp; // Pointer to single precision wave data.
522	double q;
523
524	if (p->waveHandle == NIL) {
525	SetNaN64(&p->result);
526	return NON_EXISTENT_WAVE;
527	}
528
529	q= p->x;
530
531	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
532	case NT_FP32:
533	fp= WaveData(p->waveHandle);
534	SetNaN64(&p->result);
535	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
536	case NT_FP64:
537	dp= WaveData(p->waveHandle);
538	p->result = GaussLorentzGel(dp,q);
539	return 0;
540	default: // We can't handle this wave data type.
541	SetNaN64(&p->result);
542	return REQUIRES_SP_OR_DP_WAVE;
543	}
544
545	return 0;
546	}
547
548	int
549	GaussianShellX(FitParamsPtr p)
550	{
551	double *dp; // Pointer to double precision wave data.
552	float *fp; // Pointer to single precision wave data.
553	double q;
554
555	if (p->waveHandle == NIL) {
556	SetNaN64(&p->result);
557	return NON_EXISTENT_WAVE;
558	}
559
560	q= p->x;
561
562	switch(WaveType(p->waveHandle)){ // We can handle single and double precision coefficient waves.
563	case NT_FP32:
564	fp= WaveData(p->waveHandle);
565	SetNaN64(&p->result);
566	return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07
567	case NT_FP64:
568	dp= WaveData(p->waveHandle);
569	p->result = GaussianShell(dp,q);
570	return 0;
571	default: // We can't handle this wave data type.
572	SetNaN64(&p->result);
573	return REQUIRES_SP_OR_DP_WAVE;
574	}
575
576	return 0;
577	}
578
579	///////////end of XOP
580
581

Note: See TracBrowser for help on using the repository browser.

Download in other formats: