source: sasview/sansmodels/prototypes/src/testsphere.c @ 5425990

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload
Last change on this file since 5425990 was 7df1a50, checked in by Jae Cho <jhjcho@…>, 13 years ago

moving a file
  • Property mode set to 100644
File size: 7.9 KB
Line 
1#include "testsphere.h"
2#include <stdio.h>
3#include <stdlib.h>
4#include <math.h>
5#include <time.h>
6#include <memory.h>
7#include "modelCalculations.h"
8
9
10/// 1D scattering function
11double testsphere_analytical_1D(TestSphereParameters *pars, double q) {
12        /***
13         * Things to keep here:
14         *      - volume calc
15         *  - point generation
16         * 
17         */
18       
19        // Check if Rho array is available
20        int volume_points;
21        int r_points;
22        int ptsGenerated;
23       
24        double r_step;
25        double vol;
26        double bin_width;
27        double twopiq;
28        double tmp;
29               
30        // These should be parameters
31        vol = 4.0*acos(-1.0)/3.0*pars->radius*pars->radius*pars->radius;
32       
33       
34        r_points      = pars->calcPars.r_points;
35        volume_points = pars->calcPars.volume_points;
36       
37        if(pars->calcPars.isPointMemAllocated==0) {
38               
39                // Call modelCalc function here to init_volume
40               
41                twopiq        = (2*acos(-1.0)*pars->qmax);
42                tmp           = twopiq*twopiq*twopiq*vol;
43                volume_points = (int) floor(tmp);
44                //r_points = (int) floor(10.0*pow(tmp,0.3333));
45                r_points      = (int) floor(pow(tmp,0.3333));
46                printf("v, r = %d, %d\n",volume_points, r_points); 
47               
48                // TEST
49                volume_points = 1000;
50                r_points = 1000;
51               
52                pars->calcPars.volume_points = volume_points;
53                pars->calcPars.r_points      = r_points;
54               
55                // Memory allocation
56                pars->calcPars.points = (SpacePoint*)malloc(volume_points*sizeof(SpacePoint));
57                if(pars->calcPars.points==NULL) {
58                        printf("Problem allocating memory for 1D volume points\n");
59                        return -1.0;
60                }
61                pars->calcPars.isPointMemAllocated=1;
62        }
63       
64        if(pars->calcPars.isRhoAvailable==0) {
65                // Generate random points accross the volume
66                ptsGenerated = testsphere_generatePoints(pars->calcPars.points, volume_points, pars->radius);
67               
68                // Consistency check
69                if(ptsGenerated <= 0) {
70                        // Set error code here
71                        return 0;
72                }
73               
74                // Allocate memory
75               
76                pars->calcPars.rho = (double*) malloc(r_points*sizeof(double));
77                if(pars->calcPars.rho==NULL){
78                        printf("Problem allocating memory for 1D correlation points\n");
79                        return 0;
80                }
81               
82               
83                // Lump all this in modelCalc function
84               
85                bin_width = 2.0*pars->radius/r_points;
86               
87                if(modelcalculations_calculatePairCorrelation_1D(pars->calcPars.points, volume_points, pars->calcPars.rho, r_points, bin_width)<=0){
88                        printf("Error occured!\n");
89                        return 0;
90                };
91                pars->calcPars.isRhoAvailable=1;
92        } 
93       
94        // Calculate I(q,phi) and return that value
95        r_step = 2.0*pars->radius/((double)(r_points));
96       
97        return modelcalculations_calculateIq_1D(pars->calcPars.rho, r_points, r_step, q) * vol;
98
99}
100/// 1D scattering function
101double testsphere_analytical_2D_3Darray(TestSphereParameters *pars, double q, double phi) {
102        // Check if Rho array is available
103        int volume_points;
104        int r_points;
105        int ptsGenerated;
106        double bin_width;
107        double r_step;
108        double vol;
109       
110        // These should be parameters
111        volume_points = 1000;
112        r_points = 10;
113       
114        if(pars->calcPars.isPointMemAllocated_2D==0) {
115                pars->calcPars.points_2D = (SpacePoint*)malloc(volume_points*sizeof(SpacePoint));
116                if(pars->calcPars.points_2D==NULL) {
117                        printf("Problem allocating memory for 2D volume points\n");
118                        return -1.0;
119                }
120                pars->calcPars.isPointMemAllocated_2D=1;
121        }
122                 
123        //r_step = 2.0*pars->radius/((double)(r_points));
124        // Allow negative values....
125        r_step = 4.0*pars->radius/((double)(r_points));
126       
127        if(pars->calcPars.isRhoAvailable_2D==0) {
128            // Initialize random number generator
129                int seed;   
130                seed = 10000;
131                srand(seed);
132                 
133                // Generate random points accross the volume
134                ptsGenerated = testsphere_generatePoints(pars->calcPars.points_2D, volume_points, pars->radius);
135               
136                // Calculate correlation function
137                pars->calcPars.rho_2D = (float*) malloc(r_points*r_points*r_points*sizeof(float));
138                if(pars->calcPars.rho_2D==NULL){
139                        printf("Problem allocating memory for 2D correlations points\n");
140                        return -1.0;
141                }
142                if(modelcalculations_calculatePairCorrelation_2D_3Darray(pars->calcPars.points_2D, volume_points, pars->calcPars.rho_2D, r_points, r_step)==NULL){
143                        return 0;
144                };
145                pars->calcPars.isRhoAvailable_2D=1;
146        } 
147        // Calculate I(q,phi) and return that value
148        vol = 4.0*acos(-1.0)/3.0*pars->radius*pars->radius*pars->radius;
149       
150        //printf("in ana_2D %f %f\n",q, phi);
151        return modelcalculations_calculateIq_2D_3Darray(pars->calcPars.rho_2D, r_points, r_step, q, phi)*vol;
152       
153       
154}
155
156/// 1D scattering function
157double testsphere_analytical_2D(TestSphereParameters *pars, double q, double phi) {
158        // Check if Rho array is available
159        int volume_points;
160        int r_points;
161        int ptsGenerated;
162        double bin_width;
163        double r_step;
164        double vol;
165       
166        // These should be parameters
167        //r_points      = pars->calcPars.r_points;
168        //volume_points = pars->calcPars.volume_points;
169        volume_points = 5000;
170        r_points = 100;
171       
172        if(pars->calcPars.isPointMemAllocated_2D==0) {
173                //volume_points = 2000;
174                //r_points = 100;
175                //pars->calcPars.volume_points = volume_points;
176                //pars->calcPars.r_points      = r_points;
177                pars->calcPars.points_2D = (SpacePoint*)malloc(volume_points*sizeof(SpacePoint));
178                if(pars->calcPars.points_2D==NULL) {
179                        printf("Problem allocating memory for 2D volume points\n");
180                        return -1.0;
181                }
182                pars->calcPars.isPointMemAllocated_2D=1;
183        }
184                 
185        r_step = 2.0*pars->radius/((double)(r_points));
186       
187        if(pars->calcPars.isRhoAvailable_2D==0) {
188            // Initialize random number generator
189                int seed;   
190                seed = 10000;
191                srand(seed);
192               
193                // Generate random points accross the volume
194                ptsGenerated = testsphere_generatePoints(pars->calcPars.points_2D, volume_points, pars->radius);
195               
196                // Calculate correlation function
197                pars->calcPars.rho_2D = (float*) malloc(r_points*r_points*sizeof(float));
198                if(pars->calcPars.rho_2D==NULL){
199                        printf("Problem allocating memory for 2D correlations points\n");
200                        return -1.0;
201                }
202                if(modelcalculations_calculatePairCorrelation_2D(pars->calcPars.points_2D, volume_points, pars->calcPars.rho_2D, r_points, r_step)==NULL){
203                //if(modelcalculations_calculatePairCorrelation_2D_vector(pars->calcPars.points_2D, volume_points, pars->calcPars.rho_2D, r_points, r_step,0.0,0.0,0.0)==NULL){
204                        return 0;
205                };
206                pars->calcPars.isRhoAvailable_2D=1;
207        } 
208        // Calculate I(q,phi) and return that value
209        vol = 4.0*acos(-1.0)/3.0*pars->radius*pars->radius*pars->radius;
210       
211        //printf("in ana_2D %f %f\n",q, phi);
212        return modelcalculations_calculateIq_2D(pars->calcPars.rho_2D, r_points, r_step, q, phi)*vol;   
213       
214}
215
216/// 1D scattering function
217double testsphere_numerical_1D(TestSphereParameters *pars, int *array, double q) { return 0;}
218
219/// 2D scattering function
220double testsphere_numerical_2D(TestSphereParameters *pars, int *array, double q, double phi) {return 0;}
221
222/**
223 * Generate points randomly accross the volume
224 * @param points [SpacePoint*] Array of 3D points to be filled
225 * @param n [int] Number of points to generat
226 * @param radius [double] Radius of the sphere
227 * @return Number of points generated
228 */
229int testsphere_generatePoints(SpacePoint * points, int n, double radius) {
230        int i;
231        int testcounter;
232        double x, y, z;
233       
234        // Create points       
235        // To have a uniform density, you want to generate
236        // random points in a box and keep only those that are
237        // within the volume.
238       
239        // Initialize random number generator
240        int seed;   
241        seed = 10000;
242        srand(seed);   
243       
244        testcounter = 0;
245               
246        memset(points,0,n*sizeof(SpacePoint));
247        for(i=0;i<n;i++) {
248                // Generate in a box centered around zero
249                x = (2.0*((double)rand())/((double)(RAND_MAX)+(double)(1))-1.0) * radius;
250                y = (2.0*((double)rand())/((double)(RAND_MAX)+(double)(1))-1.0) * radius;
251                z = (2.0*((double)rand())/((double)(RAND_MAX)+(double)(1))-1.0) * radius;
252               
253                // reject those that are not within the volume
254                if( sqrt(x*x+y*y+z*z) <= radius ) {
255                        points[i].x =  x;
256                        points[i].y =  y;
257                        points[i].z =  z;
258                        testcounter++;
259                } else {
260                        i--;
261                }
262        }
263        //printf("test counter = %d\n", testcounter);
264       
265        // Consistency check
266        if(testcounter != n) {
267                return -1;
268        }
269               
270        return testcounter;
271}
Note: See TracBrowser for help on using the repository browser.