Actual source code: petscimpl.h
2: /*
3: Defines the basic header of all PETSc objects.
4: */
6: #if !defined(_PETSCHEAD_H)
7: #define _PETSCHEAD_H
8: #include petsc.h
11: /*
12: All major PETSc data structures have a common core; this is defined
13: below by PETSCHEADER.
15: PetscHeaderCreate() should be used whenever creating a PETSc structure.
16: */
18: /*
19: PetscOps: structure of core operations that all PETSc objects support.
20:
21: getcomm() - Gets the object's communicator.
22: view() - Is the routine for viewing the entire PETSc object; for
23: example, MatView() is the general matrix viewing routine.
24: destroy() - Is the routine for destroying the entire PETSc object;
25: for example,MatDestroy() is the general matrix
26: destruction routine.
27: compose() - Associates a PETSc object with another PETSc object.
28: query() - Returns a different PETSc object that has been associated
29: with the first object.
30: composefunction() - Attaches an additional registered function.
31: queryfunction() - Requests a registered function that has been registered.
32: publish() - Not currently used
33: */
35: typedef struct {
36: PetscErrorCode (*getcomm)(PetscObject,MPI_Comm *);
37: PetscErrorCode (*view)(PetscObject,PetscViewer);
38: PetscErrorCode (*destroy)(PetscObject);
39: PetscErrorCode (*compose)(PetscObject,const char[],PetscObject);
40: PetscErrorCode (*query)(PetscObject,const char[],PetscObject *);
41: PetscErrorCode (*composefunction)(PetscObject,const char[],const char[],void (*)(void));
42: PetscErrorCode (*queryfunction)(PetscObject,const char[],void (**)(void));
43: PetscErrorCode (*publish)(PetscObject);
44: } PetscOps;
46: #define PETSCHEADER(ObjectOps) \
47: PetscCookie cookie; \
48: PetscOps *bops; \
49: ObjectOps *ops; \
50: PetscDataType precision; \
51: MPI_Comm comm; \
52: PetscInt type; \
53: PetscLogDouble flops,time,mem; \
54: PetscInt id; \
55: PetscInt refct; \
56: PetscMPIInt tag; \
57: PetscFList qlist; \
58: PetscOList olist; \
59: char *class_name; \
60: char *type_name; \
61: PetscObject parent; \
62: PetscInt parentid; \
63: char* name; \
64: char *prefix; \
65: void *cpp; \
66: PetscInt amem; \
67: PetscInt state; \
68: PetscInt int_idmax, intstar_idmax; \
69: PetscInt *intcomposedstate,*intstarcomposedstate; \
70: PetscInt *intcomposeddata, **intstarcomposeddata; \
71: PetscInt real_idmax, realstar_idmax; \
72: PetscInt *realcomposedstate,*realstarcomposedstate; \
73: PetscReal *realcomposeddata, **realstarcomposeddata; \
74: PetscInt scalar_idmax, scalarstar_idmax; \
75: PetscInt *scalarcomposedstate,*scalarstarcomposedstate; \
76: PetscScalar *scalarcomposeddata, **scalarstarcomposeddata; \
77: void (**fortran_func_pointers)(void)
79: /* ... */
81: #define PETSCFREEDHEADER -1
83: EXTERN PetscErrorCode PetscHeaderCreate_Private(PetscObject,PetscCookie,PetscInt,const char[],MPI_Comm,PetscErrorCode (*)(PetscObject),PetscErrorCode (*)(PetscObject,PetscViewer));
84: EXTERN PetscErrorCode PetscHeaderDestroy_Private(PetscObject);
87: typedef PetscErrorCode (*PetscObjectViewerFunction)(PetscObject,PetscViewer);
89: /*@C
90: PetscHeaderCreate - Creates a PETSc object
92: Input Parameters:
93: + tp - the data structure type of the object
94: . pops - the data structure type of the objects operations (for example VecOps)
95: . cook - the cookie associated with this object
96: . t - type (no longer should be used)
97: . class_name - string name of class; should be static
98: . com - the MPI Communicator
99: . des - the destroy routine for this object
100: - vie - the view routine for this object
102: Output Parameter:
103: . h - the newly created object
105: Level: developer
107: .seealso: PetscHeaderDestroy(), PetscLogClassRegister()
109: @*/
110: #define PetscHeaderCreate(h,tp,pops,cook,t,class_name,com,des,vie) \
111: (PetscNew(struct tp,&(h)) || \
112: PetscNew(PetscOps,&((h)->bops)) || \
113: PetscNew(pops,&((h)->ops)) || \
114: PetscHeaderCreate_Private((PetscObject)h,cook,t,class_name,com,(PetscObjectFunction)des,(PetscObjectViewerFunction)vie) || \
115: PetscLogObjectCreate(h))
117: /*@C
118: PetscHeaderDestroy - Final step in destroying a PetscObject
120: Input Parameters:
121: . h - the header created with PetscHeaderCreate()
123: Level: developer
125: .seealso: PetscHeaderCreate()
126: @*/
127: #define PetscHeaderDestroy(h) \
128: (PetscLogObjectDestroy((PetscObject)(h)) || \
129: PetscHeaderDestroy_Private((PetscObject)(h)) || \
130: PetscFree(h))
132: /* ---------------------------------------------------------------------------------------*/
134: #if !defined(PETSC_USE_DEBUG)
143: #elif !defined(PETSC_HAVE_CRAY90_POINTER)
144: /*
145: Macros to test if a PETSc object is valid and if pointers are
146: valid
148: */
150: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Object: Parameter # %d",arg);} \
151: if ((unsigned long)h & (unsigned long)3) { \
152: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Invalid Pointer to Object: Parameter # %d",arg); \
153: } \
154: if (((PetscObject)(h))->cookie != ck) { \
155: if (((PetscObject)(h))->cookie == PETSCFREEDHEADER) { \
156: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Object already free: Parameter # %d",arg); \
157: } else { \
158: SETERRQ1(PETSC_ERR_ARG_WRONG,"Wrong type of object: Parameter # %d",arg); \
159: } \
160: }}
163: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Object: Parameter # %d",arg);} \
164: if ((unsigned long)h & (unsigned long)3) { \
165: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Invalid Pointer to Object: Parameter # %d",arg); \
166: } else if (((PetscObject)(h))->cookie == PETSCFREEDHEADER) { \
167: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Object already free: Parameter # %d",arg); \
168: } else if (((PetscObject)(h))->cookie < PETSC_SMALLEST_COOKIE || \
169: ((PetscObject)(h))->cookie > PETSC_LARGEST_COOKIE) { \
170: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Invalid type of object: Parameter # %d",arg); \
171: }}
174: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Pointer: Parameter # %d",arg);} \
175: if ((unsigned long)h & (unsigned long)3){ \
176: SETERRQ1(PETSC_ERR_ARG_BADPTR,"Invalid Pointer: Parameter # %d",arg); \
177: }}
180: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Pointer: Parameter # %d",arg);} \
181: }
184: {if (!h) {SETERRQ1(PETSC_ERR_ARG_BADPTR,"Null Pointer: Parameter # %d",arg);} \
185: if ((unsigned long)h & (unsigned long)3){ \
186: SETERRQ1(PETSC_ERR_ARG_BADPTR,"Invalid Pointer to Int: Parameter # %d",arg); \
187: }}
189: #if !defined(PETSC_HAVE_DOUBLES_ALIGNED) || defined (PETSC_HAVE_DOUBLES_ALIGNED)
191: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Pointer: Parameter # %d",arg);} \
192: if ((unsigned long)h & (unsigned long)3) { \
193: SETERRQ1(PETSC_ERR_ARG_BADPTR,"Invalid Pointer to PetscScalar: Parameter # %d",arg); \
194: }}
195: #else
197: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Pointer: Parameter # %d",arg);} \
198: if ((unsigned long)h & (unsigned long)7) { \
199: SETERRQ1(PETSC_ERR_ARG_BADPTR,"Invalid Pointer to PetscScalar: Parameter # %d",arg); \
200: }}
201: #endif
203: #else
204: /*
205: Version for Cray 90 that handles pointers differently
206: */
208: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Object");} \
209: if (((PetscObject)(h))->cookie != ck) { \
210: if (((PetscObject)(h))->cookie == PETSCFREEDHEADER) { \
211: SETERRQ(PETSC_ERR_ARG_CORRUPT,"Object already free"); \
212: } else { \
213: SETERRQ(PETSC_ERR_ARG_WRONG,"Wrong Object"); \
214: } \
215: }}
218: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Object");} \
219: if (((PetscObject)(h))->cookie == PETSCFREEDHEADER) { \
220: SETERRQ(PETSC_ERR_ARG_CORRUPT,"Object already free"); \
221: } else if (((PetscObject)(h))->cookie < PETSC_SMALLEST_COOKIE || \
222: ((PetscObject)(h))->cookie > PETSC_LARGEST_COOKIE) { \
223: SETERRQ(PETSC_ERR_ARG_CORRUPT,"Invalid type of object"); \
224: }}
227: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
228: }
231: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
232: }
235: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
236: }
238: #if !defined(PETSC_HAVE_DOUBLES_ALIGNED)
240: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
241: }
242: #else
244: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
245: }
246: #endif
248: #endif
251: #if !defined(PETSC_USE_DEBUG)
258: #else
260: /*
261: For example, in the dot product between two vectors,
262: both vectors must be either Seq or MPI, not one of each
263: */
265: if ((a)->type != (b)->type) SETERRQ2(PETSC_ERR_ARG_NOTSAMETYPE,"Objects not of same type: Argument # %d and %d",arga,argb);
266: /*
267: Use this macro to check if the type is set
268: */
270: if (!(a)->type_name) SETERRQ1(PETSC_ERR_ARG_WRONGSTATE,"Object Type not set: Argument # %d",arg);
271: /*
272: Sometimes object must live on same communicator to inter-operate
273: */
275: {PetscErrorCode _6_ierr,__flag; _6_MPI_Comm_compare(((PetscObject)a)->comm,((PetscObject)b)->comm,&__flag);\
276: CHKERRQ(_6_ierr); \
277: if (__flag != MPI_CONGRUENT && __flag != MPI_IDENT) \
278: SETERRQ2(PETSC_ERR_ARG_NOTSAMECOMM,"Different communicators in the two objects: Argument # %d and %d",arga,argb);}
284: #endif
286: /*
287: All PETSc objects begin with the fields defined in PETSCHEADER.
288: The PetscObject is a way of examining these fields regardless of
289: the specific object. In C++ this could be a base abstract class
290: from which all objects are derived.
291: */
292: struct _p_PetscObject {
293: PETSCHEADER(int);
294: };
296: EXTERN PetscErrorCode PetscObjectPublishBaseBegin(PetscObject);
297: EXTERN PetscErrorCode PetscObjectPublishBaseEnd(PetscObject);
299: /*MC
300: PetscObjectStateIncrease - Increases the state of any PetscObject,
301: regardless of the type.
303: Synopsis:
304: PetscErrorCode PetscObjectStateIncrease(PetscObject obj)
306: Not Collective
308: Input Parameter:
309: . obj - any PETSc object, for example a Vec, Mat or KSP. This must be
310: cast with a (PetscObject), for example,
311: PetscObjectStateIncrease((PetscObject)mat);
313: Notes: object state is an integer which gets increased every time
314: the object is changed. By saving and later querying the object state
315: one can determine whether information about the object is still current.
316: Currently, state is maintained for Vec and Mat objects.
318: This routine is mostly for internal use by PETSc; a developer need only
319: call it after explicit access to an object's internals. Routines such
320: as VecSet or MatScale already call this routine. It is also called, as a
321: precaution, in VecRestoreArray, MatRestoreRow, MatRestoreArray.
323: Level: developer
325: seealso: PetscObjectStateQuery(), PetscObjectStateDecrease()
327: Concepts: state
329: M*/
330: #define PetscObjectStateIncrease(obj) ((obj)->state++,0)
332: /*MC
333: PetscObjectStateDecrease - Decreases the state of any PetscObject,
334: regardless of the type.
336: Synopsis:
337: PetscErrorCode PetscObjectStateDecrease(PetscObject obj)
339: Not Collective
341: Input Parameter:
342: . obj - any PETSc object, for example a Vec, Mat or KSP. This must be
343: cast with a (PetscObject), for example,
344: PetscObjectStateIncrease((PetscObject)mat);
346: Notes: object state is an integer which gets increased every time
347: the object is changed. By saving and later querying the object state
348: one can determine whether information about the object is still current.
349: Currently, state is maintained for Vec and Mat objects.
351: Level: developer
353: seealso: PetscObjectStateQuery(), PetscObjectStateIncrease()
355: Concepts: state
357: M*/
358: #define PetscObjectStateDecrease(obj) ((obj)->state--,0)
360: EXTERN PetscErrorCode PetscObjectStateQuery(PetscObject,PetscInt*);
361: EXTERN PetscErrorCode PetscObjectSetState(PetscObject,PetscInt);
362: EXTERN PetscErrorCode PetscObjectComposedDataRegister(PetscInt*);
363: EXTERN PetscErrorCode PetscObjectComposedDataIncreaseInt(PetscObject);
364: EXTERN PetscErrorCode PetscObjectComposedDataIncreaseIntstar(PetscObject);
365: EXTERN PetscErrorCode PetscObjectComposedDataIncreaseReal(PetscObject);
366: EXTERN PetscErrorCode PetscObjectComposedDataIncreaseRealstar(PetscObject);
367: EXTERN PetscErrorCode PetscObjectComposedDataIncreaseScalar(PetscObject);
368: EXTERN PetscErrorCode PetscObjectComposedDataIncreaseScalarstar(PetscObject);
369: EXTERN PetscInt globalcurrentstate;
370: EXTERN PetscInt globalmaxstate;
371: /*MC
372: PetscObjectComposedDataSetInt - attach integer data to a PetscObject
374: Synopsis:
375: PetscErrorCode PetscObjectComposedDataSetInt(PetscObject obj,int id,int data)
377: Not collective
379: Input parameters:
380: + obj - the object to which data is to be attached
381: . id - the identifier for the data
382: - data - the data to be attached
384: Notes
385: The data identifier can best be determined through a call to
386: PetscObjectComposedDataRegister()
388: Level: developer
389: M*/
390: #define PetscObjectComposedDataSetInt(obj,id,data) \
391: ((((obj)->int_idmax < globalmaxstate) ? PetscObjectComposedDataIncreaseInt(obj) : 0), \
392: (obj)->intcomposeddata[id] = data,(obj)->intcomposedstate[id] = (obj)->state, 0)
394: /*MC
395: PetscObjectComposedDataGetInt - retrieve integer data attached to an object
397: Synopsis:
398: PetscErrorCode PetscObjectComposedDataGetInt(PetscObject obj,int id,int *data,PetscTruth *flag)
400: Not collective
402: Input parameters:
403: + obj - the object from which data is to be retrieved
404: - id - the identifier for the data
406: Output parameters
407: + data - the data to be retrieved
408: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
410: The 'data' and 'flag' variables are inlined, so they are not pointers.
412: Level: developer
413: M*/
414: #define PetscObjectComposedDataGetInt(obj,id,data,flag) \
415: ((((obj)->intcomposedstate && ((obj)->intcomposedstate[id] == (obj)->state)) ? \
416: (data = (obj)->intcomposeddata[id],flag = PETSC_TRUE) : (flag = PETSC_FALSE)),0)
418: /*MC
419: PetscObjectComposedDataSetIntstar - attach integer array data to a PetscObject
421: Synopsis:
422: PetscErrorCode PetscObjectComposedDataSetIntstar(PetscObject obj,int id,int *data)
424: Not collective
426: Input parameters:
427: + obj - the object to which data is to be attached
428: . id - the identifier for the data
429: - data - the data to be attached
431: Notes
432: The data identifier can best be determined through a call to
433: PetscObjectComposedDataRegister()
435: Level: developer
436: M*/
437: #define PetscObjectComposedDataSetIntstar(obj,id,data) \
438: ((((obj)->intstar_idmax < globalmaxstate) ? PetscObjectComposedDataIncreaseIntstar(obj) : 0), \
439: (obj)->intstarcomposeddata[id] = data,(obj)->intstarcomposedstate[id] = (obj)->state, 0)
441: /*MC
442: PetscObjectComposedDataGetIntstar - retrieve integer array data
443: attached to an object
445: Synopsis:
446: PetscErrorCode PetscObjectComposedDataGetIntstar(PetscObject obj,int id,int **data,PetscTruth *flag)
448: Not collective
450: Input parameters:
451: + obj - the object from which data is to be retrieved
452: - id - the identifier for the data
454: Output parameters
455: + data - the data to be retrieved
456: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
458: The 'data' and 'flag' variables are inlined, so they are not pointers.
460: Level: developer
461: M*/
462: #define PetscObjectComposedDataGetIntstar(obj,id,data,flag) \
463: ((((obj)->intstarcomposedstate && ((obj)->intstarcomposedstate[id] == (obj)->state)) ? \
464: (data = (obj)->intstarcomposeddata[id],flag = PETSC_TRUE) : (flag = PETSC_FALSE)),0)
466: /*MC
467: PetscObjectComposedDataSetReal - attach real data to a PetscObject
469: Synopsis:
470: PetscErrorCode PetscObjectComposedDataSetReal(PetscObject obj,int id,PetscReal data)
472: Not collective
474: Input parameters:
475: + obj - the object to which data is to be attached
476: . id - the identifier for the data
477: - data - the data to be attached
479: Notes
480: The data identifier can best be determined through a call to
481: PetscObjectComposedDataRegister()
483: Level: developer
484: M*/
485: #define PetscObjectComposedDataSetReal(obj,id,data) \
486: ((((obj)->real_idmax < globalmaxstate) ? PetscObjectComposedDataIncreaseReal(obj) : 0), \
487: (obj)->realcomposeddata[id] = data,(obj)->realcomposedstate[id] = (obj)->state, 0)
489: /*MC
490: PetscObjectComposedDataGetReal - retrieve real data attached to an object
492: Synopsis:
493: PetscErrorCode PetscObjectComposedDataGetReal(PetscObject obj,int id,PetscReal *data,PetscTruth *flag)
495: Not collective
497: Input parameters:
498: + obj - the object from which data is to be retrieved
499: - id - the identifier for the data
501: Output parameters
502: + data - the data to be retrieved
503: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
505: The 'data' and 'flag' variables are inlined, so they are not pointers.
507: Level: developer
508: M*/
509: #define PetscObjectComposedDataGetReal(obj,id,data,flag) \
510: ((((obj)->realcomposedstate && ((obj)->realcomposedstate[id] == (obj)->state)) ? \
511: (data = (obj)->realcomposeddata[id],flag = PETSC_TRUE) : (flag = PETSC_FALSE)),0)
513: /*MC
514: PetscObjectComposedDataSetRealstar - attach real array data to a PetscObject
516: Synopsis:
517: PetscErrorCode PetscObjectComposedDataSetRealstar(PetscObject obj,int id,PetscReal *data)
519: Not collective
521: Input parameters:
522: + obj - the object to which data is to be attached
523: . id - the identifier for the data
524: - data - the data to be attached
526: Notes
527: The data identifier can best be determined through a call to
528: PetscObjectComposedDataRegister()
530: Level: developer
531: M*/
532: #define PetscObjectComposedDataSetRealstar(obj,id,data) \
533: ((((obj)->realstar_idmax < globalmaxstate) ? PetscObjectComposedDataIncreaseRealstar(obj) : 0), \
534: (obj)->realstarcomposeddata[id] = data, (obj)->realstarcomposedstate[id] = (obj)->state, 0)
536: /*MC
537: PetscObjectComposedDataGetRealstar - retrieve real array data
538: attached to an object
540: Synopsis:
541: PetscErrorCode PetscObjectComposedDataGetRealstar(PetscObject obj,int id,PetscReal **data,PetscTruth *flag)
543: Not collective
545: Input parameters:
546: + obj - the object from which data is to be retrieved
547: - id - the identifier for the data
549: Output parameters
550: + data - the data to be retrieved
551: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
553: The 'data' and 'flag' variables are inlined, so they are not pointers.
555: Level: developer
556: M*/
557: #define PetscObjectComposedDataGetRealstar(obj,id,data,flag) \
558: ((((obj)->realstarcomposedstate && ((obj)->realstarcomposedstate[id] == (obj)->state)) ? \
559: (data = (obj)->realstarcomposeddata[id],flag = PETSC_TRUE) : (flag = PETSC_FALSE)),0)
561: /*MC
562: PetscObjectSetScalarComposedData - attach scalar data to a PetscObject
564: Synopsis:
565: PetscErrorCode PetscObjectSetScalarComposedData(PetscObject obj,int id,PetscScalar data)
567: Not collective
569: Input parameters:
570: + obj - the object to which data is to be attached
571: . id - the identifier for the data
572: - data - the data to be attached
574: Notes
575: The data identifier can best be determined through a call to
576: PetscObjectComposedDataRegister()
578: Level: developer
579: M*/
580: #if defined(PETSC_USE_COMPLEX)
581: #define PetscObjectComposedDataSetScalar(obj,id,data) \
582: ((((obj)->scalar_idmax < globalmaxstate) ? PetscObjectComposedDataIncreaseScalar(obj) : 0) \
583: (obj)->scalarcomposeddata[id] = data,(obj)->scalarcomposedstate[id] = (obj)->state, 0)
584: #else
585: #define PetscObjectComposedDataSetScalar(obj,id,data) \
586: PetscObjectComposedDataSetReal(obj,id,data)
587: #endif
588: /*MC
589: PetscObjectComposedDataGetScalar - retrieve scalar data attached to an object
591: Synopsis:
592: PetscErrorCode PetscObjectComposedDataGetScalar(PetscObject obj,int id,PetscScalar *data,PetscTruth *flag)
594: Not collective
596: Input parameters:
597: + obj - the object from which data is to be retrieved
598: - id - the identifier for the data
600: Output parameters
601: + data - the data to be retrieved
602: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
604: The 'data' and 'flag' variables are inlined, so they are not pointers.
606: Level: developer
607: M*/
608: #if defined(PETSC_USE_COMPLEX)
609: #define PetscObjectComposedDataGetScalar(obj,id,data,flag) \
610: ((((obj)->scalarcomposedstate && ((obj)->scalarcomposedstate[id] == (obj)->state) ) ? \
611: (data = (obj)->scalarcomposeddata[id],flag = PETSC_TRUE) : (flag = PETSC_FALSE)),0)
612: #else
613: #define PetscObjectComposedDataGetScalar(obj,id,data,flag) \
614: PetscObjectComposedDataGetReal(obj,id,data,flag)
615: #endif
617: /*MC
618: PetscObjectComposedDataSetScalarstar - attach scalar array data to a PetscObject
620: Synopsis:
621: PetscErrorCode PetscObjectComposedDataSetScalarstar(PetscObject obj,int id,PetscScalar *data)
623: Not collective
625: Input parameters:
626: + obj - the object to which data is to be attached
627: . id - the identifier for the data
628: - data - the data to be attached
630: Notes
631: The data identifier can best be determined through a call to
632: PetscObjectComposedDataRegister()
634: Level: developer
635: M*/
636: #if defined(PETSC_USE_COMPLEX)
637: #define PetscObjectComposedDataSetScalarstar(obj,id,data) \
638: ((((obj)->scalarstar_idmax < globalmaxstate) ? PetscObjectComposedDataIncreaseScalarstar(obj) : 0), \
639: (obj)->scalarstarcomposeddata[id] = data,(obj)->scalarstarcomposedstate[id] = (obj)->state, 0)
640: #else
641: #define PetscObjectComposedDataSetScalarstar(obj,id,data) \
642: PetscObjectComposedDataSetRealstar(obj,id,data)
643: #endif
644: /*MC
645: PetscObjectComposedDataGetScalarstar - retrieve scalar array data
646: attached to an object
648: Synopsis:
649: PetscErrorCode PetscObjectComposedDataGetScalarstar(PetscObject obj,int id,PetscScalar **data,PetscTruth *flag)
651: Not collective
653: Input parameters:
654: + obj - the object from which data is to be retrieved
655: - id - the identifier for the data
657: Output parameters
658: + data - the data to be retrieved
659: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
661: The 'data' and 'flag' variables are inlined, so they are not pointers.
663: Level: developer
664: M*/
665: #if defined(PETSC_USE_COMPLEX)
666: #define PetscObjectComposedDataGetScalarstar(obj,id,data,flag) \
667: ((((obj)->scalarstarcomposedstate && ((obj)->scalarstarcomposedstate[id] == (obj)->state)) ? \
668: (data = (obj)->scalarstarcomposeddata[id],flag = PETSC_TRUE) : (flag = PETSC_FALSE)),0)
669: #else
670: #define PetscObjectComposedDataGetScalarstar(obj,id,data,flag) \
671: PetscObjectComposedDataGetRealstar(obj,id,data,flag)
672: #endif
674: /* some vars for logging */
679: #endif /* _PETSCHEAD_H */