Changeset 452 for sans/XOP_Dev/SANSAnalysis/XOP/Cylinder.c

Timestamp:

Nov 18, 2008 3:24:51 PM (14 years ago)

Author:

srkline

Message:

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:

• sans/XOP_Dev/SANSAnalysis/XOP/Cylinder.c (modified) (1 diff)

sans/XOP_Dev/SANSAnalysis/XOP/Cylinder.c

@@ -832 +832 @@
 }
 
+/*      SpherocylinderX
+
+*/
+int
+SpherocylinderX(FitParamsPtr p)
+{
+        double *dp;                             // Pointer to double precision wave data.
+        float *fp;                              // Pointer to single precision wave data.
+        double q;               //local variables of coefficient wave
+        
+        if (p->waveHandle == NIL) {
+                SetNaN64(&p->result);
+                return NON_EXISTENT_WAVE;
+        }
+        
+        q= p->x;
+        
+        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
+                case NT_FP32:
+                        fp= WaveData(p->waveHandle);
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                    
+                case NT_FP64:
+                        dp= WaveData(p->waveHandle);
+                        p->result = Spherocylinder(dp,q);
+                        return 0;
+                default:                                                                // We can't handle this wave data type.
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE;
+        }       
+        return 0;
+}
+
+/*      ConvexLensX
+
+*/
+int
+ConvexLensX(FitParamsPtr p)
+{
+        double *dp;                             // Pointer to double precision wave data.
+        float *fp;                              // Pointer to single precision wave data.
+        double q;               //local variables of coefficient wave
+        
+        if (p->waveHandle == NIL) {
+                SetNaN64(&p->result);
+                return NON_EXISTENT_WAVE;
+        }
+        
+        q= p->x;
+        
+        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
+                case NT_FP32:
+                        fp= WaveData(p->waveHandle);
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                    
+                case NT_FP64:
+                        dp= WaveData(p->waveHandle);
+                        p->result = ConvexLens(dp,q);
+                        return 0;
+                default:                                                                // We can't handle this wave data type.
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE;
+        }       
+        return 0;
+}
+
+/*      DumbbellX
+
+*/
+int
+DumbbellX(FitParamsPtr p)
+{
+        double *dp;                             // Pointer to double precision wave data.
+        float *fp;                              // Pointer to single precision wave data.
+        double q;               //local variables of coefficient wave
+        
+        if (p->waveHandle == NIL) {
+                SetNaN64(&p->result);
+                return NON_EXISTENT_WAVE;
+        }
+        
+        q= p->x;
+        
+        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
+                case NT_FP32:
+                        fp= WaveData(p->waveHandle);
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                    
+                case NT_FP64:
+                        dp= WaveData(p->waveHandle);
+                        p->result = Dumbbell(dp,q);
+                        return 0;
+                default:                                                                // We can't handle this wave data type.
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE;
+        }       
+        return 0;
+}
+
+/*      CappedCylinderX
+
+*/
+int
+CappedCylinderX(FitParamsPtr p)
+{
+        double *dp;                             // Pointer to double precision wave data.
+        float *fp;                              // Pointer to single precision wave data.
+        double q;               //local variables of coefficient wave
+        
+        if (p->waveHandle == NIL) {
+                SetNaN64(&p->result);
+                return NON_EXISTENT_WAVE;
+        }
+        
+        q= p->x;
+        
+        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
+                case NT_FP32:
+                        fp= WaveData(p->waveHandle);
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                    
+                case NT_FP64:
+                        dp= WaveData(p->waveHandle);
+                        p->result = CappedCylinder(dp,q);
+                        return 0;
+                default:                                                                // We can't handle this wave data type.
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE;
+        }       
+        return 0;
+}
+
+/*      BarbellX
+
+*/
+int
+BarbellX(FitParamsPtr p)
+{
+        double *dp;                             // Pointer to double precision wave data.
+        float *fp;                              // Pointer to single precision wave data.
+        double q;               //local variables of coefficient wave
+        
+        if (p->waveHandle == NIL) {
+                SetNaN64(&p->result);
+                return NON_EXISTENT_WAVE;
+        }
+        
+        q= p->x;
+        
+        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
+                case NT_FP32:
+                        fp= WaveData(p->waveHandle);
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                    
+                case NT_FP64:
+                        dp= WaveData(p->waveHandle);
+                        p->result = Barbell(dp,q);
+                        return 0;
+                default:                                                                // We can't handle this wave data type.
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE;
+        }       
+        return 0;
+}
+
+/*      Lamellar_ParaCrystalX
+
+*/
+int
+Lamellar_ParaCrystalX(FitParamsPtr p)
+{
+        double *dp;                             // Pointer to double precision wave data.
+        float *fp;                              // Pointer to single precision wave data.
+        double q;               //local variables of coefficient wave
+        
+        if (p->waveHandle == NIL) {
+                SetNaN64(&p->result);
+                return NON_EXISTENT_WAVE;
+        }
+        
+        q= p->x;
+        
+        switch(WaveType(p->waveHandle)){                        // We can handle single and double precision coefficient waves.
+                case NT_FP32:
+                        fp= WaveData(p->waveHandle);
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE; //not quite true, but good enough for now AJJ 4/23/07                    
+                case NT_FP64:
+                        dp= WaveData(p->waveHandle);
+                        p->result = Lamellar_ParaCrystal(dp,q);
+                        return 0;
+                default:                                                                // We can't handle this wave data type.
+                        SetNaN64(&p->result);
+                        return REQUIRES_SP_OR_DP_WAVE;
+        }       
+        return 0;
+}
+