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: }