00001 #include <stdio.h>
00002 #include <math.h>
00003 #include <string.h>
00004 #include <stdlib.h>
00005 #include "util.h"
00006 #include "nfft3.h"
00007
00016 double my_weight(double z,double a,double b,double c)
00017 {
00018 return pow(0.25-z*z,b)/(c+pow(fabs(z),2*a));
00019 }
00020
00022 void glacier(int N,int M)
00023 {
00024 int j,k,k0,k1,l,my_N[2],my_n[2];
00025 double tmp_y;
00026 nfft_plan p;
00027 infft_plan ip;
00028 FILE* fp;
00029
00030
00031 my_N[0]=N; my_n[0]=nfft_next_power_of_2(N);
00032 my_N[1]=N; my_n[1]=nfft_next_power_of_2(N);
00033 nfft_init_guru(&p, 2, my_N, M, my_n, 6,
00034 PRE_PHI_HUT| PRE_FULL_PSI|
00035 MALLOC_X| MALLOC_F_HAT| MALLOC_F|
00036 FFTW_INIT| FFT_OUT_OF_PLACE,
00037 FFTW_MEASURE| FFTW_DESTROY_INPUT);
00038
00039
00040 infft_init_advanced(&ip,&p, CGNE| PRECOMPUTE_DAMP);
00041
00042
00043 fp=fopen("input_data.dat","r");
00044 for(j=0;j<p.M_total;j++)
00045 {
00046 fscanf(fp,"%le %le %le",&p.x[2*j+0],&p.x[2*j+1],&tmp_y);
00047 ip.y[j]=tmp_y;
00048 }
00049 fclose(fp);
00050
00051
00052 if(p.nfft_flags & PRE_ONE_PSI)
00053 nfft_precompute_one_psi(&p);
00054
00055
00056 if(ip.flags & PRECOMPUTE_DAMP)
00057 for(k0=0;k0<p.N[0];k0++)
00058 for(k1=0;k1<p.N[1];k1++)
00059 ip.w_hat[k0*p.N[1]+k1]=
00060 my_weight(((double)(k0-p.N[0]/2))/p.N[0],0.5,3,0.001)*
00061 my_weight(((double)(k1-p.N[1]/2))/p.N[1],0.5,3,0.001);
00062
00063
00064 for(k=0;k<p.N_total;k++)
00065 ip.f_hat_iter[k]=0;
00066
00067
00068 infft_before_loop(&ip);
00069 for(l=0;l<40;l++)
00070 {
00071 fprintf(stderr,"Residual ||r||=%e,\n",sqrt(ip.dot_r_iter));
00072 infft_loop_one_step(&ip);
00073 }
00074
00075 for(k=0;k<p.N_total;k++)
00076 printf("%le %le\n",creal(ip.f_hat_iter[k]),cimag(ip.f_hat_iter[k]));
00077
00078 infft_finalize(&ip);
00079 nfft_finalize(&p);
00080 }
00081
00083 void glacier_cv(int N,int M,int M_cv,unsigned infft_flags)
00084 {
00085 int j,k,k0,k1,l,my_N[2],my_n[2];
00086 double tmp_y,r;
00087 nfft_plan p,cp;
00088 infft_plan ip;
00089 double complex* cp_y;
00090 FILE* fp;
00091 int M_re=M-M_cv;
00092
00093
00094 my_N[0]=N; my_n[0]=nfft_next_power_of_2(N);
00095 my_N[1]=N; my_n[1]=nfft_next_power_of_2(N);
00096 nfft_init_guru(&p, 2, my_N, M_re, my_n, 6,
00097 PRE_PHI_HUT| PRE_FULL_PSI|
00098 MALLOC_X| MALLOC_F_HAT| MALLOC_F|
00099 FFTW_INIT| FFT_OUT_OF_PLACE,
00100 FFTW_MEASURE| FFTW_DESTROY_INPUT);
00101
00102
00103
00104 infft_init_advanced(&ip,&p, infft_flags);
00105
00106
00107
00108
00109 cp_y = (double complex*) fftw_malloc(M*sizeof(double complex));
00110 nfft_init_guru(&cp, 2, my_N, M, my_n, 6,
00111 PRE_PHI_HUT| PRE_FULL_PSI|
00112 MALLOC_X| MALLOC_F|
00113 FFTW_INIT| FFT_OUT_OF_PLACE,
00114 FFTW_MEASURE| FFTW_DESTROY_INPUT);
00115
00116 cp.f_hat=ip.f_hat_iter;
00117
00118
00119 fp=fopen("input_data.dat","r");
00120 for(j=0;j<cp.M_total;j++)
00121 {
00122 fscanf(fp,"%le %le %le",&cp.x[2*j+0],&cp.x[2*j+1],&tmp_y);
00123 cp_y[j]=tmp_y;
00124 }
00125 fclose(fp);
00126
00127
00128 for(j=0;j<p.M_total;j++)
00129 {
00130 p.x[2*j+0]=cp.x[2*j+0];
00131 p.x[2*j+1]=cp.x[2*j+1];
00132 ip.y[j]=tmp_y;
00133 }
00134
00135
00136 if(p.nfft_flags & PRE_ONE_PSI)
00137 nfft_precompute_one_psi(&p);
00138
00139
00140 if(cp.nfft_flags & PRE_ONE_PSI)
00141 nfft_precompute_one_psi(&cp);
00142
00143
00144 if(ip.flags & PRECOMPUTE_DAMP)
00145 for(k0=0;k0<p.N[0];k0++)
00146 for(k1=0;k1<p.N[1];k1++)
00147 ip.w_hat[k0*p.N[1]+k1]=
00148 my_weight(((double)(k0-p.N[0]/2))/p.N[0],0.5,3,0.001)*
00149 my_weight(((double)(k1-p.N[1]/2))/p.N[1],0.5,3,0.001);
00150
00151
00152 for(k=0;k<p.N_total;k++)
00153 ip.f_hat_iter[k]=0;
00154
00155
00156 infft_before_loop(&ip);
00157
00158 for(l=0;l<40;l++)
00159 infft_loop_one_step(&ip);
00160
00161
00162
00163 NFFT_SWAP_complex(p.f_hat,ip.f_hat_iter);
00164 nfft_trafo(&p);
00165 NFFT_SWAP_complex(p.f_hat,ip.f_hat_iter);
00166 nfft_upd_axpy_complex(p.f,-1,ip.y,M_re);
00167 r=sqrt(nfft_dot_complex(p.f,M_re)/nfft_dot_complex(cp_y,M));
00168 fprintf(stderr,"r=%1.2e, ",r);
00169 printf("$%1.1e$ & ",r);
00170
00171 nfft_trafo(&cp);
00172 nfft_upd_axpy_complex(&cp.f[M_re],-1,&cp_y[M_re],M_cv);
00173 r=sqrt(nfft_dot_complex(&cp.f[M_re],M_cv)/nfft_dot_complex(cp_y,M));
00174 fprintf(stderr,"r_1=%1.2e\t",r);
00175 printf("$%1.1e$ & ",r);
00176
00177 nfft_finalize(&cp);
00178 infft_finalize(&ip);
00179 nfft_finalize(&p);
00180 }
00181
00182
00184 int main(int argc, char **argv)
00185 {
00186 int M_cv;
00187
00188 if(argc<3)
00189 {
00190 fprintf(stderr,"Call this program from the Matlab script glacier.m!");
00191 exit(-1);
00192 }
00193
00194 if(argc==3)
00195 glacier(atoi(argv[1]),atoi(argv[2]));
00196 else
00197 for(M_cv=atoi(argv[3]);M_cv<=atoi(argv[5]);M_cv+=atoi(argv[4]))
00198 {
00199 fprintf(stderr,"\nM_cv=%d,\t",M_cv);
00200 printf("$%d$ & ",M_cv);
00201 fprintf(stderr,"cgne+damp: ");
00202 glacier_cv(atoi(argv[1]),atoi(argv[2]),M_cv,CGNE| PRECOMPUTE_DAMP);
00203
00204
00205 fprintf(stderr,"cgnr: ");
00206 glacier_cv(atoi(argv[1]),atoi(argv[2]),M_cv,CGNR);
00207 fprintf(stderr,"cgnr: ");
00208 glacier_cv(atoi(argv[1])/4,atoi(argv[2]),M_cv,CGNR);
00209 printf("XXX \\\\\n");
00210 }
00211
00212 fprintf(stderr,"\n");
00213
00214 return 1;
00215 }
00216