Main Page   Data Structures   File List   Data Fields   Globals  

fas.c File Reference

#include "utilf.h"
#include "mymalloc.h"
#include "make_bc.h"
#include "fas.h"

Include dependency graph for fas.c:

Include dependency graph

Go to the source code of this file.

Defines

#define COARSEST   1
#define COARSERELAX   4

Functions

void lop (real2D out, real2D u, real2D a, real2D b, int n1, int n2)
int computeng (int n1, int n2)
int initpressure (int n1, int n2, int ng)
void mginit (real2D u, real2D p, real2D a, real2D b, real2D ei, real2D cc, int n1, int n2, int ng)
void mgfas (real2D u, real2D p, real2D a, real2D b, real2D ei, int n1, int n2, int ng, int npre, int npost, int ncycle)
void relax (real2D u, real2D rhs, real2D a, real2D b, real2D ei, real2D cc, int n1, int n2)
void lop (real2D out, real2D u, real2D a, real2D b, real2D cc, int n1, int n2)

Define Documentation

#define COARSERELAX   4
 

Definition at line 15 of file fas.c.

#define COARSEST   1
 

Definition at line 14 of file fas.c.

Function Documentation

int computeng (  int    n1,
int    n2
) 
 

Definition at line 35 of file fas.c. 

00036 {
00037   int nmin, n, nn, j;
00038 
00039   nmin = min(n1, n2);
00040   
00041   j = nmin - 2;  n = 1;
00042   while (j > 2) 
00043   {  j /= 2;   n++;  }
00044   
00045   nn = 1;  
00046   for (j = 1; j <= n; j++) 
00047     nn *= 2;       
00048   if((nn + 2) != nmin)
00049      return NGERROR;
00050 
00051   if ((n1 - 2) % (nmin - 2) != 0)
00052      return NXERROR;
00053   if ((n2 - 2) % (nmin - 2) != 0)
00054      return NYERROR;
00055   
00056   return n;
00057 }

int initpressure (  int    n1,
int    n2,
int    ng
) 
 

Definition at line 61 of file fas.c. 

00062 {
00063   int j;
00064   
00065   irhs = (real2D *) malloc((ng + 1) * sizeof(real2D));
00066   irho = (real2D *) malloc((ng + 1) * sizeof(real2D));
00067   itau = (real2D *) malloc((ng + 1) * sizeof(real2D));
00068   ip = (real2D *) malloc((ng + 1) * sizeof(real2D));
00069   ia = (real2D *) malloc((ng + 1) * sizeof(real2D));
00070   ib = (real2D *) malloc((ng + 1) * sizeof(real2D));
00071   iei = (real2D *) malloc((ng + 1) * sizeof(real2D));
00072   itemp = (real2D *) malloc((ng + 1) * sizeof(real2D));
00073   icc = (real2D *) malloc((ng + 1) * sizeof(real2D));
00074   
00075   if (icc EQUALS NULL)
00076       return MEMERROR;
00077   
00078   irhs[ng] = (real2D)mymalloc(sizeof(real), n1, n2);
00079   itau[ng] = (real2D)mymalloc(sizeof(real), n1, n2); 
00080   itemp[ng] = (real2D)mymalloc(sizeof(real), n1, n2);
00081 
00082   n1 = n1 / 2 + 1;
00083   n2 = n2 / 2 + 1;
00084 
00085   for (j = ng - 1; j >= 1; j--)
00086     {
00087       irhs[j] = (real2D)mymalloc(sizeof(real), n1, n2); 
00088       irho[j] = (real2D)mymalloc(sizeof(real), n1, n2); 
00089       itau[j] = (real2D)mymalloc(sizeof(real), n1, n2); 
00090       ip[j] = (real2D)mymalloc(sizeof(real), n1, n2); 
00091       ia[j] = (real2D)mymalloc(sizeof(real), n1, n2);
00092       ib[j] = (real2D)mymalloc(sizeof(real), n1, n2); 
00093       iei[j] = (real2D)mymalloc(sizeof(real), n1, n2); 
00094       icc[j] = (real2D)mymalloc(sizeof(real), n1, n2);
00095       itemp[j] = (real2D)mymalloc(sizeof(real), n1, n2);
00096 
00097       if (itemp[j] EQUALS NULL)
00098         return MEMERROR;
00099 
00100       n1 = n1 / 2 + 1;
00101       n2 = n2 / 2 + 1;
00102     }
00103     
00104   return 0;
00105 } /* end initpressure() */

void lop (  real2D    out,
real2D    u,
real2D    a,
real2D    b,
real2D    cc,
int    n1,
int    n2
) 
 

Definition at line 445 of file fas.c.

References real, and real2D.

Referenced by mgfas(). 

00447 {
00448   int i, j;
00449   real hi2;
00450 
00451   hi2 = (real) (n2 - 2) * (n2 - 2);
00452   for (i = 2; i <= n1 - 1; i++)
00453     for (j = 2; j <= n2 - 1; j++)
00454       if (cc[i][j] == 1.0)
00455         out[i][j] = hi2 * (a[i][j] * (u[i+1][j] - u[i][j]) +
00456                            a[i-1][j] * (u[i-1][j] - u[i][j]) +
00457                            b[i][j] * (u[i][j+1] - u[i][j]) +
00458                            b[i][j-1] * (u[i][j-1] - u[i][j]));
00459 }

void lop (  real2D    out,
real2D    u,
real2D    a,
real2D    b,
int    n1,
int    n2
) 
 

void mgfas (  real2D    u,
real2D    p,
real2D    a,
real2D    b,
real2D    ei,
int    n1,
int    n2,
int    ng,
int    npre,
int    npost,
int    ncycle
) 
 

Definition at line 143 of file fas.c.

References bc_scalar(), copy(), lop(), NULGRAD, real2D, and relax(). 

00145 {
00146   int i, j, jj, jcycle, jpre, jpost, ngrid, nfx, nfy, nn1, nn2;
00147 
00148   ip[ng] = p;
00149   irho[ng] = u;
00150   ia[ng] = a;
00151   ib[ng] = b;
00152   iei[ng] = ei;  
00153   icc[ng] = cc;
00154 
00155   nn1 = n1 / 2 + 1;
00156   nn2 = n2 / 2 + 1;
00157   ngrid = ng - 1;
00158   
00159   bc_scalar(u, n1, n2, NULGRAD);
00160 
00161   rstrct(irho[ngrid], u, nn1, nn2);
00162   rstrct(icc[ngrid], cc, nn1, nn2);
00163   abfromab(ia[ngrid], ib[ngrid], iei[ngrid],
00164            ia[ngrid+1], ib[ngrid+1], nn1, nn2);
00165   while ((nn1 > 4) && (nn2 > 4))
00166     {
00167       nn1 = nn1 / 2 + 1;
00168       nn2 = nn2 / 2 + 1;
00169       ngrid = ngrid - 1;      
00170       rstrct(irho[ngrid], irho[ngrid+1], nn1, nn2);
00171       rstrct(icc[ngrid], icc[ngrid+1], nn1, nn2);
00172       abfromab(ia[ngrid], ib[ngrid], iei[ngrid], ia[ngrid+1], ib[ngrid+1],
00173                nn1, nn2);
00174     }
00175 
00176   ngrid = ng;
00177   for (j = 2; j <= ngrid; j++)
00178     {
00179       nn1 = 2 * nn1 - 2;
00180       nn2 = 2 * nn2 - 2;
00181       interp(ip[j], ip[j-1], nn1, nn2);
00182       copy(irhs[j], irho[j], nn1, nn2);
00183       for (jcycle = 1; jcycle <= ncycle; jcycle++)
00184         {
00185           nfx = nn1;
00186           nfy = nn2;
00187           for (jj = j; jj >= 2; jj--)
00188             {
00189               for (jpre = 1; jpre <= npre; jpre++)
00190                 {
00191                   relax(ip[jj], irhs[jj], ia[jj], ib[jj], iei[jj], icc[jj],
00192                         nfx, nfy);
00193                   bc_scalar(ip[jj], nfx, nfy, NULGRAD);
00194                 }
00195               lop(itemp[jj], ip[jj], ia[jj], ib[jj], icc[jj], nfx, nfy);              
00196               bc_scalar(itemp[jj], nfx, nfy, NULGRAD);
00197               nfx = nfx / 2 + 1;
00198               nfy = nfy / 2 + 1;
00199               rstrct(itemp[jj-1], itemp[jj], nfx, nfy);
00200               rstrct(ip[jj-1], ip[jj], nfx, nfy);
00201               lop(itau[jj-1], ip[jj-1], ia[jj-1], ib[jj-1], icc[jj-1], nfx, nfy);
00202               bc_scalar(itau[jj-1], nfx, nfy, NULGRAD);
00203               matsub(itau[jj-1], itemp[jj-1], itau[jj-1], nfx, nfy);
00204               rstrct(irhs[jj-1], irhs[jj], nfx, nfy);
00205               matadd(irhs[jj-1], itau[jj-1], irhs[jj-1], nfx, nfy);
00206             }
00207           
00208           slvsml(ip[1], irhs[1],
00209                  ia[1], ib[1], iei[1], icc[1], nfx, nfy);
00210           
00211           for (jj = 2; jj <= j; jj++)
00212             {
00213               rstrct(itemp[jj-1], ip[jj], nfx, nfy);
00214               matsub(ip[jj-1], itemp[jj-1], itemp[jj-1], nfx, nfy);
00215               nfx = 2 * nfx - 2;
00216               nfy = 2 * nfy - 2;
00217               interp(itau[jj], itemp[jj-1], nfx, nfy);
00218               matadd(ip[jj], itau[jj], ip[jj], nfx, nfy);
00219               for (jpost = 1; jpost <= npost; jpost++)
00220                 {
00221                   relax(ip[jj], irhs[jj], ia[jj], ib[jj], iei[jj], icc[jj],
00222                         nfx, nfy);
00223                   bc_scalar(ip[jj], nfx, nfy, NULGRAD);
00224                 }
00225             }  
00226         }
00227     }
00228 }

void mginit (  real2D    u,
real2D    p,
real2D    a,
real2D    b,
real2D    ei,
real2D    cc,
int    n1,
int    n2,
int    ng
) 
 

Definition at line 109 of file fas.c.

References bc_scalar(), NULGRAD, and real2D. 

00111 {
00112   int ngrid, nn1, nn2;
00113   
00114   ip[ng] = p;
00115   irho[ng] = u;
00116   ia[ng] = a;
00117   ib[ng] = b;
00118   iei[ng] = ei;
00119   icc[ng] = cc;
00120 
00121   nn1 = n1 / 2 + 1;
00122   nn2 = n2 / 2 + 1;
00123   ngrid = ng - 1;
00124   
00125   bc_scalar(u, n1, n2, NULGRAD);
00126 
00127   rstrct(irho[ngrid], u, nn1, nn2);
00128   rstrct(icc[ngrid], p, nn1, nn2);  
00129   abfromab(ia[ngrid], ib[ngrid], iei[ngrid],
00130            ia[ngrid+1], ib[ngrid+1], nn1, nn2);
00131   while ((nn1 > 4) && (nn2 > 4))
00132     {
00133       nn1 = nn1 / 2 + 1;
00134       nn2 = nn2 / 2 + 1;
00135       ngrid = ngrid - 1;
00136       rstrct(irho[ngrid], irho[ngrid+1], nn1, nn2);
00137       rstrct(icc[ngrid], icc[ngrid+1], nn1, nn2);
00138       abfromab(ia[ngrid], ib[ngrid], iei[ngrid], ia[ngrid+1], ib[ngrid+1],
00139                nn1, nn2);
00140     }
00141 }

void relax (  real2D    u,
real2D    rhs,
real2D    a,
real2D    b,
real2D    ei,
real2D    cc,
int    n1,
int    n2
) 
 

Definition at line 418 of file fas.c. 

00421 {
00422   real h2, h, res;
00423   int i, j, isw, jsw;
00424 
00425   h = 1.0 / (n2 - 2);
00426   h2 = h * h;
00427   for (jsw = 1; jsw <= 2; jsw++)
00428     {
00429       isw = jsw;
00430       for (i = 2; i <= n1 - 1; i++, isw = 3 - isw)
00431         for (j = isw + 1; j <= n2 - 1; j += 2)
00432           if (cc[i][j] == 1.0)
00433             u[i][j] = (a[i][j] * u[i+1][j] +
00434                        a[i-1][j] * u[i-1][j] +
00435                        b[i][j] * u[i][j+1] +
00436                        b[i][j-1] * u[i][j-1]
00437                        - h2 * rhs[i][j]) 
00438               * ei[i][j];
00439     }
00440 }

Generated on Wed Feb 19 22:27:11 2003 for Markers by doxygen1.2.18