Actual source code: ex21.c

  1: /*$Id: ex21.c,v 1.9 2001/04/10 19:37:05 bsmith Exp $*/

  3: static char help[] = "Solves PDE optimization problem.nn";

 5:  #include petscda.h
 6:  #include petscpf.h
 7:  #include petscsnes.h

  9: /*

 11:        w - design variables (what we change to get an optimal solution)
 12:        u - state variables (i.e. the PDE solution)
 13:        lambda - the Lagrange multipliers

 15:             U = (w u lambda)

 17:        fu, fw, flambda contain the gradient of L(w,u,lambda)

 19:             FU = (fw fu flambda)

 21:        In this example the PDE is 
 22:                              Uxx = 2, 
 23:                             u(0) = w(0), thus this is the free parameter
 24:                             u(1) = 0
 25:        the function we wish to minimize is 
 26:                             integral u^{2}

 28:        The exact solution for u is given by u(x) = x*x - 1.25*x + .25

 30:        Use the usual centered finite differences.

 32:        Note we treat the problem as non-linear though it happens to be linear

 34:        See ex22.c for the same code, but that interlaces the u and the lambda

 36: */

 38: typedef struct {
 39:   DA      da1,da2;
 40:   int     nredundant;
 41:   VecPack packer;
 42:   PetscViewer  u_viewer,lambda_viewer;
 43:   PetscViewer  fu_viewer,flambda_viewer;
 44: } UserCtx;

 46: extern int FormFunction(SNES,Vec,Vec,void*);
 47: extern int Monitor(SNES,int,PetscReal,void*);


 50: int main(int argc,char **argv)
 51: {
 52:   int     ierr,N = 5,its;
 53:   Vec     U,FU;
 54:   SNES    snes;
 55:   UserCtx user;

 57:   PetscInitialize(&argc,&argv,(char*)0,help);
 58:   PetscOptionsGetInt(PETSC_NULL,"-N",&N,PETSC_NULL);

 60:   /* Create a global vector that includes a single redundant array and two da arrays */
 61:   VecPackCreate(PETSC_COMM_WORLD,&user.packer);
 62:   user.nredundant = 1;
 63:   VecPackAddArray(user.packer,user.nredundant);
 64:   DACreate1d(PETSC_COMM_WORLD,DA_NONPERIODIC,N,1,1,PETSC_NULL,&user.da1);
 65:   VecPackAddDA(user.packer,user.da1);
 66:   DACreate1d(PETSC_COMM_WORLD,DA_NONPERIODIC,N,1,1,PETSC_NULL,&user.da2);
 67:   VecPackAddDA(user.packer,user.da2);
 68:   VecPackCreateGlobalVector(user.packer,&U);
 69:   VecDuplicate(U,&FU);

 71:   /* create graphics windows */
 72:   PetscViewerDrawOpen(PETSC_COMM_WORLD,0,"u - state variables",-1,-1,-1,-1,&user.u_viewer);
 73:   PetscViewerDrawOpen(PETSC_COMM_WORLD,0,"lambda - Lagrange multipliers",-1,-1,-1,-1,&user.lambda_viewer);
 74:   PetscViewerDrawOpen(PETSC_COMM_WORLD,0,"fu - derivate w.r.t. state variables",-1,-1,-1,-1,&user.fu_viewer);
 75:   PetscViewerDrawOpen(PETSC_COMM_WORLD,0,"flambda - derivate w.r.t. Lagrange multipliers",-1,-1,-1,-1,&user.flambda_viewer);


 78:   /* create nonlinear solver */
 79:   SNESCreate(PETSC_COMM_WORLD,SNES_NONLINEAR_EQUATIONS,&snes);
 80:   SNESSetFunction(snes,FU,FormFunction,&user);
 81:   SNESSetFromOptions(snes);
 82:   SNESSetMonitor(snes,Monitor,&user,0);
 83:   SNESSolve(snes,U,&its);
 84:   SNESDestroy(snes);

 86:   DADestroy(user.da1);
 87:   DADestroy(user.da2);
 88:   VecPackDestroy(user.packer);
 89:   VecDestroy(U);
 90:   VecDestroy(FU);
 91:   PetscViewerDestroy(user.u_viewer);
 92:   PetscViewerDestroy(user.lambda_viewer);
 93:   PetscViewerDestroy(user.fu_viewer);
 94:   PetscViewerDestroy(user.flambda_viewer);
 95:   PetscFinalize();
 96:   return 0;
 97: }
 98: 
 99: /*
100:       Evaluates FU = Gradiant(L(w,u,lambda))

102: */
103: int FormFunction(SNES snes,Vec U,Vec FU,void* dummy)
104: {
105:   UserCtx *user = (UserCtx*)dummy;
106:   int     ierr,xs,xm,i,N;
107:   Scalar  *u,*lambda,*w,*fu,*fw,*flambda,d,h;
108:   Vec     vu,vlambda,vfu,vflambda;

111:   VecPackGetLocalVectors(user->packer,&w,&vu,&vlambda);
112:   VecPackGetLocalVectors(user->packer,&fw,&vfu,&vflambda);
113:   VecPackScatter(user->packer,U,w,vu,vlambda);

115:   DAGetCorners(user->da1,&xs,PETSC_NULL,PETSC_NULL,&xm,PETSC_NULL,PETSC_NULL);
116:   DAGetInfo(user->da1,0,&N,0,0,0,0,0,0,0,0,0);
117:   DAVecGetArray(user->da1,vu,(void**)&u);
118:   DAVecGetArray(user->da1,vfu,(void**)&fu);
119:   DAVecGetArray(user->da1,vlambda,(void**)&lambda);
120:   DAVecGetArray(user->da1,vflambda,(void**)&flambda);
121:   d    = (N-1.0);
122:   h    = 1.0/d;

124:   /* derivative of L() w.r.t. w */
125:   if (xs == 0) { /* only first processor computes this */
126:     fw[0] = -2.*d*lambda[0];
127:   }

129:   /* derivative of L() w.r.t. u */
130:   for (i=xs; i<xs+xm; i++) {
131:     if      (i == 0)   flambda[0]   =    h*u[0]   + 2.*d*lambda[0]   - d*lambda[1];
132:     else if (i == 1)   flambda[1]   = 2.*h*u[1]   + 2.*d*lambda[1]   - d*lambda[2];
133:     else if (i == N-1) flambda[N-1] =    h*u[N-1] + 2.*d*lambda[N-1] - d*lambda[N-2];
134:     else if (i == N-2) flambda[N-2] = 2.*h*u[N-2] + 2.*d*lambda[N-2] - d*lambda[N-3];
135:     else               flambda[i]   = 2.*h*u[i]   - d*(lambda[i+1] - 2.0*lambda[i] + lambda[i-1]);
136:   }

138:   /* derivative of L() w.r.t. lambda */
139:   for (i=xs; i<xs+xm; i++) {
140:     if      (i == 0)   fu[0]   = 2.0*d*(u[0] - w[0]);
141:     else if (i == N-1) fu[N-1] = 2.0*d*u[N-1];
142:     else               fu[i]   = -(d*(u[i+1] - 2.0*u[i] + u[i-1]) - 2.0*h);
143:   }

145:   DAVecRestoreArray(user->da1,vu,(void**)&u);
146:   DAVecRestoreArray(user->da1,vfu,(void**)&fu);
147:   DAVecRestoreArray(user->da1,vlambda,(void**)&lambda);
148:   DAVecRestoreArray(user->da1,vflambda,(void**)&flambda);

150:   VecPackGather(user->packer,FU,fw,vfu,vflambda);
151:   VecPackRestoreLocalVectors(user->packer,&w,&vu,&vlambda);
152:   VecPackRestoreLocalVectors(user->packer,&fw,&vfu,&vflambda);
153:   return(0);
154: }

156: int Monitor(SNES snes,int its,PetscReal rnorm,void *dummy)
157: {
158:   UserCtx *user = (UserCtx*)dummy;
159:   int     ierr;
160:   Scalar  *w;
161:   Vec     u,lambda,U,F;

164:   SNESGetSolution(snes,&U);
165:   VecPackGetAccess(user->packer,U,&w,&u,&lambda);
166:   VecView(u,user->u_viewer);
167:   VecView(lambda,user->lambda_viewer);
168:   VecPackRestoreAccess(user->packer,U,&w,&u,&lambda);

170:   SNESGetFunction(snes,&F,0,0);
171:   VecPackGetAccess(user->packer,F,&w,&u,&lambda);
172:   VecView(u,user->fu_viewer);
173:   VecView(lambda,user->flambda_viewer);
174:   VecPackRestoreAccess(user->packer,F,&w,&u,&lambda);
175:   return(0);
176: }

178: /* 
179:    This is currently not used. It computes the exact solution */

181: /*
182: int u_solution(void *dummy,int n,Scalar *x,Scalar *u)
183: {
184:   int i;
186:   for (i=0; i<n; i++) {
187:     u[i] = x[i]*x[i] - 1.25*x[i] + .25;
188:   }
189:   return(0);
190: }

192:   PF      pf;
193:   Vec     x;
194:   Vec     u_global;
195:   Scalar  *w;
196:   PFCreate(PETSC_COMM_WORLD,1,1,&pf);
197:   PFSetType(pf,PFQUICK,(void*)u_solution);
198:   DASetUniformCoordinates(user.da1,0.0,1.0,0.0,1.0,0.0,1.0);
199:   DAGetCoordinates(user.da1,&x);
200:   VecPackGetAccess(user.packer,U,&w,&u_global,0);
201:   w[0] = .25;
202:   PFApplyVec(pf,x,u_global);
203:   PFDestroy(pf);
204: */