Actual source code: state.c

petsc-dev 2014-02-02
Report Typos and Errors
  2: /*
  3:      Provides utility routines for manulating any type of PETSc object.
  4: */
  5: #include <petsc-private/petscimpl.h>  /*I   "petscsys.h"    I*/

  9: /*@C
 10:    PetscObjectStateGet - Gets the state of any PetscObject,
 11:    regardless of the type.

 13:    Not Collective

 15:    Input Parameter:
 16: .  obj - any PETSc object, for example a Vec, Mat or KSP. This must be
 17:          cast with a (PetscObject), for example,
 18:          PetscObjectStateGet((PetscObject)mat,&state);

 20:    Output Parameter:
 21: .  state - the object state

 23:    Notes: object state is an integer which gets increased every time
 24:    the object is changed. By saving and later querying the object state
 25:    one can determine whether information about the object is still current.
 26:    Currently, state is maintained for Vec and Mat objects.

 28:    Level: advanced

 30:    seealso: PetscObjectStateIncrease(), PetscObjectStateSet()

 32:    Concepts: state

 34: @*/
 35: PetscErrorCode PetscObjectStateGet(PetscObject obj,PetscObjectState *state)
 36: {
 40:   *state = obj->state;
 41:   return(0);
 42: }

 46: /*@C
 47:    PetscObjectStateSet - Sets the state of any PetscObject,
 48:    regardless of the type.

 50:    Logically Collective

 52:    Input Parameter:
 53: +  obj - any PETSc object, for example a Vec, Mat or KSP. This must be
 54:          cast with a (PetscObject), for example,
 55:          PetscObjectStateSet((PetscObject)mat,state);
 56: -  state - the object state

 58:    Notes: This function should be used with extreme caution. There is
 59:    essentially only one use for it: if the user calls Mat(Vec)GetRow(Array),
 60:    which increases the state, but does not alter the data, then this
 61:    routine can be used to reset the state.  Such a reset must be collective.

 63:    Level: advanced

 65:    seealso: PetscObjectStateGet(),PetscObjectStateIncrease()

 67:    Concepts: state

 69: @*/
 70: PetscErrorCode PetscObjectStateSet(PetscObject obj,PetscObjectState state)
 71: {
 74:   obj->state = state;
 75:   return(0);
 76: }

 78: PetscInt PetscObjectComposedDataMax = 10;

 82: /*@C
 83:    PetscObjectComposedDataRegister - Get an available id for
 84:    composed data

 86:    Not Collective

 88:    Output parameter:
 89: .  id - an identifier under which data can be stored

 91:    Level: developer

 93:    seealso: PetscObjectComposedDataSetInt()

 95: @*/
 96: PetscErrorCode  PetscObjectComposedDataRegister(PetscInt *id)
 97: {
 98:   static PetscInt globalcurrentstate = 0;

101:   *id = globalcurrentstate++;
102:   if (globalcurrentstate > PetscObjectComposedDataMax) PetscObjectComposedDataMax += 10;
103:   return(0);
104: }

108: PetscErrorCode  PetscObjectComposedDataIncreaseInt(PetscObject obj)
109: {
110:   PetscInt         *ar = obj->intcomposeddata,*new_ar,n = obj->int_idmax,new_n,i;
111:   PetscObjectState *ir = obj->intcomposedstate,*new_ir;
112:   PetscErrorCode   ierr;

115:   new_n = PetscObjectComposedDataMax;
116:   PetscCalloc1(new_n,&new_ar);
117:   PetscCalloc1(new_n,&new_ir);
118:   if (n) {
119:     for (i=0; i<n; i++) {
120:       new_ar[i] = ar[i]; new_ir[i] = ir[i];
121:     }
122:     PetscFree(ar);
123:     PetscFree(ir);
124:   }
125:   obj->int_idmax       = new_n;
126:   obj->intcomposeddata = new_ar; obj->intcomposedstate = new_ir;
127:   return(0);
128: }

132: PetscErrorCode  PetscObjectComposedDataIncreaseIntstar(PetscObject obj)
133: {
134:   PetscInt         **ar = obj->intstarcomposeddata,**new_ar,n = obj->intstar_idmax,new_n,i;
135:   PetscObjectState *ir  = obj->intstarcomposedstate,*new_ir;
136:   PetscErrorCode   ierr;

139:   new_n = PetscObjectComposedDataMax;
140:   PetscCalloc1(new_n,&new_ar);
141:   PetscCalloc1(new_n,&new_ir);
142:   if (n) {
143:     for (i=0; i<n; i++) {
144:       new_ar[i] = ar[i]; new_ir[i] = ir[i];
145:     }
146:     PetscFree(ar);
147:     PetscFree(ir);
148:   }
149:   obj->intstar_idmax       = new_n;
150:   obj->intstarcomposeddata = new_ar; obj->intstarcomposedstate = new_ir;
151:   return(0);
152: }

156: PetscErrorCode  PetscObjectComposedDataIncreaseReal(PetscObject obj)
157: {
158:   PetscReal        *ar = obj->realcomposeddata,*new_ar;
159:   PetscObjectState *ir = obj->realcomposedstate,*new_ir;
160:   PetscInt         n   = obj->real_idmax,new_n,i;
161:   PetscErrorCode   ierr;

164:   new_n = PetscObjectComposedDataMax;
165:   PetscCalloc1(new_n,&new_ar);
166:   PetscCalloc1(new_n,&new_ir);
167:   if (n) {
168:     for (i=0; i<n; i++) {
169:       new_ar[i] = ar[i]; new_ir[i] = ir[i];
170:     }
171:     PetscFree(ar);
172:     PetscFree(ir);
173:   }
174:   obj->real_idmax       = new_n;
175:   obj->realcomposeddata = new_ar; obj->realcomposedstate = new_ir;
176:   return(0);
177: }

181: PetscErrorCode  PetscObjectComposedDataIncreaseRealstar(PetscObject obj)
182: {
183:   PetscReal        **ar = obj->realstarcomposeddata,**new_ar;
184:   PetscObjectState *ir  = obj->realstarcomposedstate,*new_ir;
185:   PetscInt         n    = obj->realstar_idmax,new_n,i;
186:   PetscErrorCode   ierr;

189:   new_n = PetscObjectComposedDataMax;
190:   PetscCalloc1(new_n,&new_ar);
191:   PetscCalloc1(new_n,&new_ir);
192:   if (n) {
193:     for (i=0; i<n; i++) {
194:       new_ar[i] = ar[i]; new_ir[i] = ir[i];
195:     }
196:     PetscFree(ar);
197:     PetscFree(ir);
198:   }
199:   obj->realstar_idmax       = new_n;
200:   obj->realstarcomposeddata = new_ar; obj->realstarcomposedstate = new_ir;
201:   return(0);
202: }

206: PetscErrorCode  PetscObjectComposedDataIncreaseScalar(PetscObject obj)
207: {
208:   PetscScalar      *ar = obj->scalarcomposeddata,*new_ar;
209:   PetscObjectState *ir = obj->scalarcomposedstate,*new_ir;
210:   PetscInt         n   = obj->scalar_idmax,new_n,i;
211:   PetscErrorCode   ierr;

214:   new_n = PetscObjectComposedDataMax;
215:   PetscCalloc1(new_n,&new_ar);
216:   PetscCalloc1(new_n,&new_ir);
217:   if (n) {
218:     for (i=0; i<n; i++) {
219:       new_ar[i] = ar[i]; new_ir[i] = ir[i];
220:     }
221:     PetscFree(ar);
222:     PetscFree(ir);
223:   }
224:   obj->scalar_idmax       = new_n;
225:   obj->scalarcomposeddata = new_ar; obj->scalarcomposedstate = new_ir;
226:   return(0);
227: }

231: PetscErrorCode  PetscObjectComposedDataIncreaseScalarstar(PetscObject obj)
232: {
233:   PetscScalar      **ar = obj->scalarstarcomposeddata,**new_ar;
234:   PetscObjectState *ir  = obj->scalarstarcomposedstate,*new_ir;
235:   PetscInt         n    = obj->scalarstar_idmax,new_n,i;
236:   PetscErrorCode   ierr;

239:   new_n = PetscObjectComposedDataMax;
240:   PetscCalloc1(new_n,&new_ar);
241:   PetscCalloc1(new_n,&new_ir);
242:   if (n) {
243:     for (i=0; i<n; i++) {
244:       new_ar[i] = ar[i]; new_ir[i] = ir[i];
245:     }
246:     PetscFree(ar);
247:     PetscFree(ir);
248:   }
249:   obj->scalarstar_idmax       = new_n;
250:   obj->scalarstarcomposeddata = new_ar; obj->scalarstarcomposedstate = new_ir;
251:   return(0);
252: }

256: /*@
257:    PetscObjectGetId - get unique object ID

259:    Not Collective

261:    Input Arguments:
262: .  obj - object

264:    Output Arguments:
265: .  id - integer ID

267:    Level: developer

269:    Notes:
270:    The object ID may be different on different processes, but object IDs are never reused so local equality implies global equality.

272: .seealso: PetscObjectStateGet()
273: @*/
274: PetscErrorCode PetscObjectGetId(PetscObject obj,PetscObjectId *id)
275: {

278:   *id = obj->id;
279:   return(0);
280: }