Actual source code: gridConst.c

  1: #ifdef PETSC_RCS_HEADER
  2: static char vcid[] = "$Id: gridConst.c,v 1.1 1999/10/17 19:47:46 knepley Exp $";
  3: #endif

 5:  #include src/grid/gridimpl.h

  7: /*--------------------------------------------- Constraint Functions ------------------------------------------------*/
  8: /*@C
  9:   GridIsConstrained - This function indicates whether or not constraints are active.

 11:   Not collective

 13:   Input Parameter:
 14: . grid - The grid

 16:   Output Parameter:
 17: . flag - The flag that indicates activate constraints

 19:   Level: intermediate

 21: .keywords constraint
 22: .seealso GridSetConstrained(), GridSetupConstraints()
 23: @*/
 24: int GridIsConstrained(Grid grid, PetscTruth *flag)
 25: {
 29:   *flag = grid->isConstrained;
 30:   return(0);
 31: }

 33: /*@C
 34:   GridSetConstrained -  This function activates or deactivates constraints.

 36:   Collective on Grid

 38:   Input Parameters:
 39: + grid - The grid
 40: - flag - The activation flag

 42:   Level: intermediate

 44: .keywords constraint
 45: .seealso GridIsConstrained(), GridSetupConstraints()
 46: @*/
 47: int GridSetConstrained(Grid grid, PetscTruth flag)
 48: {
 51:   grid->isConstrained = flag;
 52:   return(0);
 53: }

 55: /*@C
 56:   GridGetNumNewFields - This function returns the number of fields introduced by constraints.

 58:   Not collective

 60:   Input Parameter:
 61: . grid         - The grid

 63:   Output Parameter:
 64: . numNewFields - The number of fields introduced by constraints

 66:   Level: intermediate

 68: .keywords constraint
 69: .seealso GridSetNumNewFields(), GridSetupConstraints()
 70: @*/
 71: int GridGetNumNewFields(Grid grid, int *numNewFields)
 72: {
 76:   *numNewFields = grid->numNewFields;
 77:   return(0);
 78: }

 80: /*@C
 81:   GridSetNumNewFields -  This function sets the number of fields introduced by constraints.

 83:   Collective on Grid

 85:   Input Parameters:
 86: + grid         - The grid
 87: - numNewFields - The number of fields introduced by constraints

 89:   Level: intermediate

 91: .keywords constraint
 92: .seealso GridGetNumNewFields(), GridSetupConstraints()
 93: @*/
 94: int GridSetNumNewFields(Grid grid, int numNewFields)
 95: {
 98:   grid->numNewFields = numNewFields;
 99:   return(0);
100: }

102: /*@C
103:   GridIsFieldConstrained - This function indicates whether or not a field is constrained.

105:   Not collective

107:   Input Parameters:
108: + grid          - The grid
109: - field         - The field

111:   Output Parameter:
112: . isConstrained - The flag that indicates whether the field is constrained

114:   Level: intermediate

116: .keywords constraint, field
117: .seealso GridIsConstrained(), GridSetupConstraints()
118: @*/
119: int GridIsFieldConstrained(Grid grid, int field, PetscTruth *isConstrained)
120: {
124:   GridValidField(grid, field);
125:   *isConstrained = grid->fields[field].isConstrained;
126:   return(0);
127: }

129: /*@C
130:   GridSetFieldConstrained - This function determines whether or not a field is constrained.

132:   Not collective

134:   Input Parameters:
135: + grid          - The grid
136: . field         - The field
137: - isConstrained - The flag that determines whether the field is constrained

139:   Level: intermediate

141: .keywords constraint, field
142: .seealso GridSetConstrained(), GridSetupConstraints()
143: @*/
144: int GridSetFieldConstrained(Grid grid, int field, PetscTruth isConstrained)
145: {
148:   GridValidField(grid, field);
149:   grid->fields[field].isConstrained = isConstrained;
150:   return(0);
151: }

153: /*@C
154:   GridGetFieldConstraintCompDiff - This function returns the constraint component difference

156:   Not collective

158:   Input Parameter:
159: + grid               - The grid
160: - field              - The field

162:   Output Parameter:
163: . constraintCompDiff - The difference between the number of components in the new and constrained field

165:   Level: intermediate

167: .keywords constraint, field
168: .seealso GridIsConstrained(), GridSetupConstraints()
169: @*/
170: int GridGetFieldConstraintCompDiff(Grid grid, int field, int *constraintCompDiff)
171: {
175:   GridValidField(grid, field);
176:   *constraintCompDiff = grid->fields[field].constraintCompDiff;
177:   return(0);
178: }

180: /*@C
181:   GridSetFieldConstraintCompDiff - This function sets the constraint component difference

183:   Not collective

185:   Input Parameters:
186: + grid               - The grid
187: . field              - The field
188: - constraintCompDiff - The difference between the number of components in the new and constrained field

190:   Level: intermediate

192: .keywords constraint, field
193: .seealso GridSetConstrained(), GridSetupConstraints()
194: @*/
195: int GridSetFieldConstraintCompDiff(Grid grid, int field, int constraintCompDiff)
196: {
199:   GridValidField(grid, field);
200:   grid->fields[field].constraintCompDiff = constraintCompDiff;
201:   return(0);
202: }

204: /*@C
205:   GridGetExplicitConstraints - This function indicates whether or not constrained
206:   objects are formed explicitly or implicitly.

208:   Not collective

210:   Input Parameter:
211: . grid - The grid

213:   Output Parameter:
214: . flag - The flag that indicates explicit constraints

216:   Note:
217:   Objects formed explicitly are actually vectors and matrices, whereas
218:   constrained objects formed implicitly are products of projection
219:   operators and normal objects.

221:   Level: intermediate

223: .keywords constraint
224: .seealso GridSetExplicitConstraints(), GridSetupConstraints()
225: @*/
226: int GridGetExplicitConstraints(Grid grid, PetscTruth *flag)
227: {
231:   *flag = grid->explicitConstraints;
232:   return(0);
233: }

235: /*@C
236:   GridSetExplicitConstraints - This function determines how to form constrained objects.

238:   Collective on Grid

240:   Input Parameters:
241: + grid - The grid
242: - flag - The formation flag

244:   Note:
245:   Objects formed explicitly are actually vectors and matrices, whereas
246:   constrained objects formed implicitly are products of projection
247:   operators and normal objects.

249:   Level: intermediate

251: .keywords constraint
252: .seealso GridGetExplicitConstraints(), GridSetupConstraints()
253: @*/
254: int GridSetExplicitConstraints(Grid grid, PetscTruth flag)
255: {
258:   grid->explicitConstraints = flag;
259:   return(0);
260: }

262: /*@C
263:   GridGetConstraints - This function return information about the constrained problem.

265:   Not collective

267:   Input Parameter:
268: . grid            - The grid

270:   Output Parameters:
271: + flag            - The flag that activates constraints
272: . numInteriorVars - The number of constrained variables unaffected by constraints in this domain
273: . numLocVars      - The number of constrained variables in this domain
274: - numVars         - The global number of constrained variables

276:   Level: advanced

278: .keywords constraint
279: .seealso GridSetBoundary
280: @*/
281: int GridGetConstraints(Grid grid, PetscTruth *flag, int *numInteriorVars, int *numLocVars, int *numVars)
282: {
285:   if (flag            != PETSC_NULL) {
287:     *flag = grid->isConstrained;
288:   }
289:   if (numInteriorVars != PETSC_NULL) {
291:     *numInteriorVars = grid->constraintOrder->numLocVars - grid->constraintOrder->numLocNewVars;
292:   }
293:   if (numLocVars      != PETSC_NULL) {
295:     *numLocVars      = grid->constraintOrder->numLocVars;
296:   }
297:   if (numVars         != PETSC_NULL) {
299:     *numVars         = grid->constraintOrder->numVars;
300:   }
301:   return(0);
302: }

304: /*@C
305:   GridGetConstraintContext - This function returns the constraint context or PETSC_NULL if no constraints exist.

307:   Not collective

309:   Input Parameter:
310: . grid - The grid

312:   Output Parameter:
313: . ctx  - The constraint context

315:   Level: intermediate

317: .keywords constraint, context
318: .seealso GridSetConstraintContext(), GridSetConstraints()
319: @*/
320: int GridGetConstraintContext(Grid grid, PetscConstraintObject *ctx)
321: {
325:   *ctx = grid->constraintCtx;
326:   return(0);
327: }

329: /*@C
330:   GridSetConstraintContext - This function sets the context for the constrained problem.

332:   Collective on Grid

334:   Input Parameters:
335: + grid - The grid
336: - ctx  - The constraint context

338:   Level: intermediate

340: .keywords constraint, context
341: .seealso GridGetConstraintContext(), GridSetConstraints()
342: @*/
343: int GridSetConstraintContext(Grid grid, PetscConstraintObject ctx)
344: {
347:   grid->constraintCtx = ctx;
348:   return(0);
349: }

351: /*@C
352:   GridGetConstraintMatrix - This function returns the projector from the constrained to the unconstrained variables,
353:   or PETSC_NULL if no projector exists.

355:   Collective on Grid

357:   Input Parameter:
358: . grid - The grid

360:   Output Parameters:
361: . P    - The projector from constrained to the unconstrained variables

363:   Level: intermediate

365: .keywords constraint
366: .seealso GridSetupConstraints()
367: @*/
368: int GridGetConstraintMatrix(Grid grid, GMat *P)
369: {
373:   *P = grid->constraintMatrix;
374:   return(0);
375: }

377: /*@C
378:   GridGetConstraintInverse - This function returns the psuedo-inverse of the projector from the constrained
379:   to the unconstrained variables, or PETSC_NULL if no inverse exists.

381:   Collective on Grid

383:   Input Parameter:
384: . grid - The grid

386:   Output Parameter:
387: . invP - The pseudo-inverse of the projector from constrained to the unconstrained variables

389:   Level: intermediate

391: .keywords constraint
392: .seealso GridSetupConstraints()
393: @*/
394: int GridGetConstraintInverse(Grid grid, GMat *invP)
395: {
399:   *invP = grid->constraintInverse;
400:   return(0);
401: }