NFFT Logo 3.0.2 API Reference
Main Page | Modules | Data Structures | Directories | File List | Data Fields | Globals

glacier.c

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   /* initialise p */
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   /* initialise ip, specific */
00040   infft_init_advanced(&ip,&p, CGNE| PRECOMPUTE_DAMP);
00041 
00042   /* init nodes */
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   /* precompute psi */
00052   if(p.nfft_flags & PRE_ONE_PSI)
00053       nfft_precompute_one_psi(&p);
00054   
00055   /* initialise damping factors */
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   /* init some guess */
00064   for(k=0;k<p.N_total;k++)
00065       ip.f_hat_iter[k]=0; 
00066 
00067   /* inverse trafo */  
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   /* initialise p for reconstruction */
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   /* initialise ip, specific */
00104   infft_init_advanced(&ip,&p, infft_flags);
00105 
00106   
00107   
00108   /* initialise cp for validation */
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   /* set up data in cp and cp_y */
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   /* copy part of the data to p and ip */
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   /* precompute psi */
00136   if(p.nfft_flags & PRE_ONE_PSI)
00137     nfft_precompute_one_psi(&p);
00138    
00139   /* precompute psi */
00140   if(cp.nfft_flags & PRE_ONE_PSI)
00141     nfft_precompute_one_psi(&cp);
00142    
00143   /* initialise damping factors */
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   /* init some guess */
00152   for(k=0;k<p.N_total;k++)
00153       ip.f_hat_iter[k]=0;
00154 
00155   /* inverse trafo */  
00156   infft_before_loop(&ip);
00157   //  fprintf(stderr,"iteration starts,\t");
00158   for(l=0;l<40;l++)
00159     infft_loop_one_step(&ip);
00160 
00161   //fprintf(stderr,"r=%1.2e, ",sqrt(ip.dot_r_iter)/M_re);
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   //fprintf(stderr,"cgne: ");
00204   //glacier_cv(atoi(argv[1]),atoi(argv[2]),M_cv,CGNE);
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 /* \} */

Generated on 22 Jan 2007 by Doxygen 1.4.1