Actual source code: destroy.c

  1: #define PETSC_DLL
  2: /*
  3:      Provides utility routines for manulating any type of PETSc object.
  4: */
 5:  #include petscsys.h

  7: typedef struct _p_GenericObject* GenericObject;

  9: struct _p_GenericObject {
 10:   PETSCHEADER(int);
 11: };

 13: PetscErrorCode PetscObjectDestroy_GenericObject(GenericObject obj)
 14: {
 18:   if (--((PetscObject)obj)->refct > 0) return(0);
 19:   PetscHeaderDestroy(obj);
 20:   return(0);
 21: }

 23: PetscErrorCode PetscComposedQuantitiesDestroy(PetscObject obj)
 24: {
 27:   if (obj->intstar_idmax>0) {
 28:     for (i=0; i<obj->intstar_idmax; i++) {
 29:       if (obj->intstarcomposeddata[i]) {
 30:         PetscFree(obj->intstarcomposeddata[i]);
 31:         obj->intstarcomposeddata[i] = 0;
 32:       }
 33:     }
 34:     PetscFree(obj->intstarcomposeddata);
 35:     PetscFree(obj->intstarcomposedstate);
 36:   }
 37:   if (obj->realstar_idmax>0) {
 38:     for (i=0; i<obj->realstar_idmax; i++) {
 39:       if (obj->realstarcomposeddata[i]) {
 40:         PetscFree(obj->realstarcomposeddata[i]);
 41:         obj->realstarcomposeddata[i] = 0;
 42:       }
 43:     }
 44:     PetscFree(obj->realstarcomposeddata);
 45:     PetscFree(obj->realstarcomposedstate);
 46:   }
 47:   if (obj->scalarstar_idmax>0) {
 48:     for (i=0; i<obj->scalarstar_idmax; i++) {
 49:       if (obj->scalarstarcomposeddata[i]) {
 50:         PetscFree(obj->scalarstarcomposeddata[i]);
 51:         obj->scalarstarcomposeddata[i] = 0;
 52:       }
 53:     }
 54:     PetscFree(obj->scalarstarcomposeddata);
 55:     PetscFree(obj->scalarstarcomposedstate);
 56:   }
 57:   return(0);
 58: }

 62: /*@C
 63:    PetscObjectCreate - Creates a PetscObject

 65:    Collective on PetscObject

 67:    Input Parameter:
 68: .  comm - An MPI communicator

 70:    Output Parameter:
 71: .  obj - The object

 73:    Level: developer

 75:    Notes: This is a template intended as a starting point to cut and paste with PetscObjectDestroy_GenericObject()
 76:           to make new object classes.

 78:     Concepts: destroying object
 79:     Concepts: freeing object
 80:     Concepts: deleting object

 82: @*/
 83: PetscErrorCode  PetscObjectCreate(MPI_Comm comm, PetscObject *obj)
 84: {
 85:   GenericObject  o;

 90: #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
 91:   PetscInitializePackage(PETSC_NULL);
 92: #endif
 93:   PetscHeaderCreate(o,_p_GenericObject,-1,PETSC_OBJECT_COOKIE,0,"PetscObject",comm,PetscObjectDestroy_GenericObject,0);
 94:   /* records not yet defined in PetscObject 
 95:   o->data        = 0;
 96:   o->setupcalled = 0;
 97:   */
 98:   *obj = (PetscObject)o;
 99:   return(0);
100: }

104: /*@C
105:    PetscObjectCreateGeneric - Creates a PetscObject

107:    Collective on PetscObject

109:    Input Parameter:
110: +  comm - An MPI communicator
111: .  cookie - The class cookie
112: -  name - The class name

114:    Output Parameter:
115: .  obj - The object

117:    Level: developer

119:    Notes: This is a template intended as a starting point to cut and paste with PetscObjectDestroy_GenericObject()
120:           to make new object classes.

122:     Concepts: destroying object
123:     Concepts: freeing object
124:     Concepts: deleting object

126: @*/
127: PetscErrorCode  PetscObjectCreateGeneric(MPI_Comm comm, PetscCookie cookie, const char name[], PetscObject *obj)
128: {
129:   GenericObject  o;

134: #if !defined(PETSC_USE_DYNAMIC_LIBRARIES)
135:   PetscInitializePackage(PETSC_NULL);
136: #endif
137:   PetscHeaderCreate(o,_p_GenericObject,-1,cookie,0,name,comm,PetscObjectDestroy_GenericObject,0);
138:   /* records not yet defined in PetscObject 
139:   o->data        = 0;
140:   o->setupcalled = 0;
141:   */
142:   *obj = (PetscObject)o;
143:   return(0);
144: }

148: /*@
149:    PetscObjectDestroy - Destroys any PetscObject, regardless of the type. 

151:    Collective on PetscObject

153:    Input Parameter:
154: .  obj - any PETSc object, for example a Vec, Mat or KSP.
155:          This must be cast with a (PetscObject), for example, 
156:          PetscObjectDestroy((PetscObject)mat);

158:    Level: beginner

160:     Concepts: destroying object
161:     Concepts: freeing object
162:     Concepts: deleting object

164: @*/
165: PetscErrorCode  PetscObjectDestroy(PetscObject obj)
166: {

171:   if (obj->bops->destroy) {
172:     (*obj->bops->destroy)(obj);
173:   } else {
174:     SETERRQ1(PETSC_ERR_PLIB,"This PETSc object of class %s does not have a generic destroy routine",obj->class_name);
175:   }
176:   return(0);
177: }

181: /*@C
182:    PetscObjectView - Views any PetscObject, regardless of the type. 

184:    Collective on PetscObject

186:    Input Parameters:
187: +  obj - any PETSc object, for example a Vec, Mat or KSP.
188:          This must be cast with a (PetscObject), for example, 
189:          PetscObjectView((PetscObject)mat,viewer);
190: -  viewer - any PETSc viewer

192:    Level: intermediate

194: @*/
195: PetscErrorCode  PetscObjectView(PetscObject obj,PetscViewer viewer)
196: {

201:   if (!viewer) {
202:     PetscViewerASCIIGetStdout(obj->comm,&viewer);
203:   }

206:   if (obj->bops->view) {
207:     (*obj->bops->view)(obj,viewer);
208:   } else {
209:     SETERRQ(PETSC_ERR_SUP,"This PETSc object does not have a generic viewer routine");
210:   }
211:   return(0);
212: }

216: /*@C
217:    PetscTypeCompare - Determines whether a PETSc object is of a particular type.

219:    Not Collective

221:    Input Parameters:
222: +  obj - any PETSc object, for example a Vec, Mat or KSP.
223:          This must be cast with a (PetscObject), for example, 
224:          PetscObjectDestroy((PetscObject)mat);
225: -  type_name - string containing a type name

227:    Output Parameter:
228: .  same - PETSC_TRUE if they are the same, else PETSC_FALSE
229:   
230:    Level: intermediate

232: .seealso: VecGetType(), KSPGetType(), PCGetType(), SNESGetType()

234:    Concepts: comparing^object types
235:    Concepts: types^comparing
236:    Concepts: object type^comparing

238: @*/
239: PetscErrorCode  PetscTypeCompare(PetscObject obj,const char type_name[],PetscTruth *same)
240: {

244:   if (!obj) {
245:     *same = PETSC_FALSE;
246:   } else if (!type_name && !obj->type_name) {
247:     *same = PETSC_TRUE;
248:   } else if (!type_name || !obj->type_name) {
249:     *same = PETSC_FALSE;
250:   } else {
254:     PetscStrcmp((char*)(obj->type_name),type_name,same);
255:   }
256:   return(0);
257: }

259: #define MAXREGDESOBJS 256
260: static int         PetscObjectRegisterDestroy_Count = 0;
261: static PetscObject PetscObjectRegisterDestroy_Objects[MAXREGDESOBJS];

265: /*@C
266:    PetscObjectRegisterDestroy - Registers a PETSc object to be destroyed when
267:      PetscFinalize() is called.

269:    Collective on PetscObject

271:    Input Parameter:
272: .  obj - any PETSc object, for example a Vec, Mat or KSP.
273:          This must be cast with a (PetscObject), for example, 
274:          PetscObjectRegisterDestroy((PetscObject)mat);

276:    Level: developer

278:    Notes:
279:       This is used by, for example, PETSC_VIEWER_XXX_() routines to free the viewer
280:     when PETSc ends.

282: .seealso: PetscObjectRegisterDestroyAll()
283: @*/
284: PetscErrorCode  PetscObjectRegisterDestroy(PetscObject obj)
285: {
288:   if (PetscObjectRegisterDestroy_Count < MAXREGDESOBJS) {
289:     PetscObjectRegisterDestroy_Objects[PetscObjectRegisterDestroy_Count++] = obj;
290:   } else {
291:     SETERRQ1(PETSC_ERR_PLIB,"No more room in array, limit %d \n recompile src/sys/objects/destroy.c with larger value for MAXREGDESOBJS\n",MAXREGDESOBJS);
292: 
293:   }
294:   return(0);
295: }

299: /*@C
300:    PetscObjectRegisterDestroyAll - Frees all the PETSc objects that have been registered
301:      with PetscObjectRegisterDestroy(). Called by PetscFinalize()

303:    Collective on individual PetscObjects

305:    Level: developer

307: .seealso: PetscObjectRegisterDestroy()
308: @*/
309: PetscErrorCode  PetscObjectRegisterDestroyAll(void)
310: {
312:   int i;

315:   for (i=0; i<PetscObjectRegisterDestroy_Count; i++) {
316:     PetscObjectDestroy(PetscObjectRegisterDestroy_Objects[i]);
317:   }
318:   PetscObjectRegisterDestroy_Count = 0;
319:   return(0);
320: }


323: #define MAXREGFIN 256
324: static int         PetscRegisterFinalize_Count = 0;
325: static PetscErrorCode ((*PetscRegisterFinalize_Functions[MAXREGFIN])(void));

329: /*@C
330:    PetscRegisterFinalize - Registers a function that is to be called in PetscFinalize()

332:    Not Collective

334:    Input Parameter:
335: .  PetscErrorCode (*fun)(void) - 

337:    Level: developer

339:    Notes:
340:       This is used by, for example, DMInitializePackage() to have DMFinalizePackage() called

342: .seealso: PetscRegisterFinalizeAll()
343: @*/
344: PetscErrorCode  PetscRegisterFinalize(PetscErrorCode (*f)(void))
345: {

348:   if (PetscRegisterFinalize_Count < MAXREGFIN) {
349:     PetscRegisterFinalize_Functions[PetscRegisterFinalize_Count++] = f;
350:   } else {
351:     SETERRQ1(PETSC_ERR_PLIB,"No more room in array, limit %d \n recompile src/sys/objects/destroy.c with larger value for MAXREGFIN\n",MAXREGFIN);
352: 
353:   }
354:   return(0);
355: }

359: /*@C
360:    PetscRegisterFinalizeAll - Runs all the finalize functions set with PetscRegisterFinalize()

362:    Not Collective unless registered functions are collective

364:    Level: developer

366: .seealso: PetscRegisterFinalize()
367: @*/
368: PetscErrorCode  PetscRegisterFinalizeAll(void)
369: {
371:   int i;

374:   for (i=0; i<PetscRegisterFinalize_Count; i++) {
375:     (*PetscRegisterFinalize_Functions[i])();
376:   }
377:   PetscRegisterFinalize_Count = 0;
378:   return(0);
379: }