Actual source code: petschead.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: reference() - Increases the reference count for a PETSc object; when
25: a reference count reaches zero it is destroyed.
26: destroy() - Is the routine for destroying the entire PETSc object;
27: for example,MatDestroy() is the general matrix
28: destruction routine.
29: compose() - Associates a PETSc object with another PETSc object.
30: query() - Returns a different PETSc object that has been associated
31: with the first object.
32: composefunction() - Attaches an additional registered function.
33: queryfunction() - Requests a registered function that has been registered.
34: composelanguage() - associates the object's representation in a different language
35: querylanguage() - obtain the object's representation in a different language
36: */
38: typedef struct {
39: PetscErrorCode (*getcomm)(PetscObject,MPI_Comm *);
40: PetscErrorCode (*view)(PetscObject,PetscViewer);
41: PetscErrorCode (*reference)(PetscObject);
42: PetscErrorCode (*destroy)(PetscObject);
43: PetscErrorCode (*compose)(PetscObject,const char[],PetscObject);
44: PetscErrorCode (*query)(PetscObject,const char[],PetscObject *);
45: PetscErrorCode (*composefunction)(PetscObject,const char[],const char[],void (*)(void));
46: PetscErrorCode (*queryfunction)(PetscObject,const char[],void (**)(void));
47: PetscErrorCode (*composelanguage)(PetscObject,PetscLanguage,void *);
48: PetscErrorCode (*querylanguage)(PetscObject,PetscLanguage,void **);
49: PetscErrorCode (*publish)(PetscObject);
50: } PetscOps;
52: #define PETSCHEADER(ObjectOps) \
53: PetscCookie cookie; \
54: PetscOps *bops; \
55: ObjectOps *ops; \
56: MPI_Comm comm; \
57: PetscInt type; \
58: PetscLogDouble flops,time,mem; \
59: PetscInt id; \
60: PetscInt refct; \
61: PetscMPIInt tag; \
62: PetscFList qlist; \
63: PetscOList olist; \
64: char *class_name; \
65: char *type_name; \
66: PetscObject parent; \
67: PetscInt parentid; \
68: char* name; \
69: char *prefix; \
70: void *cpp; \
71: PetscInt amem; \
72: PetscInt state; \
73: PetscInt int_idmax, intstar_idmax; \
74: PetscInt *intcomposedstate,*intstarcomposedstate; \
75: PetscInt *intcomposeddata, **intstarcomposeddata; \
76: PetscInt real_idmax, realstar_idmax; \
77: PetscInt *realcomposedstate,*realstarcomposedstate; \
78: PetscReal *realcomposeddata, **realstarcomposeddata; \
79: PetscInt scalar_idmax, scalarstar_idmax; \
80: PetscInt *scalarcomposedstate,*scalarstarcomposedstate; \
81: PetscScalar *scalarcomposeddata, **scalarstarcomposeddata; \
82: void (**fortran_func_pointers)(void);
84: /* ... */
86: #define PETSCFREEDHEADER -1
88: EXTERN PetscErrorCode PetscHeaderCreate_Private(PetscObject,PetscCookie,PetscInt,const char[],MPI_Comm,PetscErrorCode (*)(PetscObject),PetscErrorCode (*)(PetscObject,PetscViewer));
89: EXTERN PetscErrorCode PetscHeaderDestroy_Private(PetscObject);
92: typedef PetscErrorCode (*PetscObjectViewerFunction)(PetscObject,PetscViewer);
94: /*
95: PetscHeaderCreate - Creates a PETSc object
97: Input Parameters:
98: + tp - the data structure type of the object
99: . pops - the data structure type of the objects operations (for example VecOps)
100: . cook - the cookie associated with this object
101: . t - type (no longer should be used)
102: . class_name - string name of class; should be static
103: . com - the MPI Communicator
104: . des - the destroy routine for this object
105: - vie - the view routine for this object
107: Output Parameter:
108: . h - the newly created object
109: */
110: #define PetscHeaderCreate(h,tp,pops,cook,t,class_name,com,des,vie) \
111: { PetscErrorCode _ierr; \
112: _PetscNew(struct tp,&(h));CHKERRQ(_ierr); \
113: _PetscMemzero(h,sizeof(struct tp));CHKERRQ(_ierr); \
114: _PetscNew(PetscOps,&((h)->bops));CHKERRQ(_ierr); \
115: _PetscMemzero((h)->bops,sizeof(PetscOps));CHKERRQ(_ierr); \
116: _PetscNew(pops,&((h)->ops));CHKERRQ(_ierr); \
117: _PetscMemzero((h)->ops,sizeof(pops));CHKERRQ(_ierr); \
118: _PetscHeaderCreate_Private((PetscObject)h,cook,t,class_name,com, \
119: (PetscObjectFunction)des, \
120: (PetscObjectViewerFunction)vie);CHKERRQ(_ierr); \
121: }
123: #define PetscHeaderDestroy(h) \
124: { PetscErrorCode _ierr; \
125: _PetscHeaderDestroy_Private((PetscObject)(h));CHKERRQ(_ierr);\
126: }
128: /* ---------------------------------------------------------------------------------------*/
130: #if !defined(PETSC_HAVE_CRAY90_POINTER)
131: /*
132: Macros to test if a PETSc object is valid and if pointers are
133: valid
135: */
137: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Object: Parameter # %d",arg);} \
138: if ((unsigned long)h & (unsigned long)3) { \
139: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Invalid Pointer to Object: Parameter # %d",arg); \
140: } \
141: if (((PetscObject)(h))->cookie != ck) { \
142: if (((PetscObject)(h))->cookie == PETSCFREEDHEADER) { \
143: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Object already free: Parameter # %d",arg); \
144: } else { \
145: SETERRQ1(PETSC_ERR_ARG_WRONG,"Wrong type of object: Parameter # %d",arg); \
146: } \
147: }}
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: } else if (((PetscObject)(h))->cookie == PETSCFREEDHEADER) { \
154: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Object already free: Parameter # %d",arg); \
155: } else if (((PetscObject)(h))->cookie < PETSC_COOKIE || \
156: ((PetscObject)(h))->cookie > PETSC_LARGEST_COOKIE) { \
157: SETERRQ1(PETSC_ERR_ARG_CORRUPT,"Invalid type of object: Parameter # %d",arg); \
158: }}
161: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Pointer: Parameter # %d",arg);} \
162: if ((unsigned long)h & (unsigned long)3){ \
163: SETERRQ1(PETSC_ERR_ARG_BADPTR,"Invalid Pointer: Parameter # %d",arg); \
164: }}
167: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Pointer: Parameter # %d",arg);} \
168: }
171: {if (!h) {SETERRQ1(PETSC_ERR_ARG_BADPTR,"Null Pointer: Parameter # %d",arg);} \
172: if ((unsigned long)h & (unsigned long)3){ \
173: SETERRQ1(PETSC_ERR_ARG_BADPTR,"Invalid Pointer to Int: Parameter # %d",arg); \
174: }}
176: #if !defined(PETSC_HAVE_DOUBLES_ALIGNED) || defined (PETSC_HAVE_DOUBLES_ALIGNED)
178: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Pointer: Parameter # %d",arg);} \
179: if ((unsigned long)h & (unsigned long)3) { \
180: SETERRQ1(PETSC_ERR_ARG_BADPTR,"Invalid Pointer to PetscScalar: Parameter # %d",arg); \
181: }}
182: #else
184: {if (!h) {SETERRQ1(PETSC_ERR_ARG_NULL,"Null Pointer: Parameter # %d",arg);} \
185: if ((unsigned long)h & (unsigned long)7) { \
186: SETERRQ1(PETSC_ERR_ARG_BADPTR,"Invalid Pointer to PetscScalar: Parameter # %d",arg); \
187: }}
188: #endif
190: #else
191: /*
192: Version for Cray 90 that handles pointers differently
193: */
195: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Object");} \
196: if (((PetscObject)(h))->cookie != ck) { \
197: if (((PetscObject)(h))->cookie == PETSCFREEDHEADER) { \
198: SETERRQ(PETSC_ERR_ARG_CORRUPT,"Object already free"); \
199: } else { \
200: SETERRQ(PETSC_ERR_ARG_WRONG,"Wrong Object"); \
201: } \
202: }}
205: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Object");} \
206: if (((PetscObject)(h))->cookie == PETSCFREEDHEADER) { \
207: SETERRQ(PETSC_ERR_ARG_CORRUPT,"Object already free"); \
208: } else if (((PetscObject)(h))->cookie < PETSC_COOKIE || \
209: ((PetscObject)(h))->cookie > PETSC_LARGEST_COOKIE) { \
210: SETERRQ(PETSC_ERR_ARG_CORRUPT,"Invalid type of object"); \
211: }}
214: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
215: }
218: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
219: }
222: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
223: }
225: #if !defined(PETSC_HAVE_DOUBLES_ALIGNED)
227: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
228: }
229: #else
231: {if (!h) {SETERRQ(PETSC_ERR_ARG_NULL,"Null Pointer");} \
232: }
233: #endif
235: #endif
238: /*
239: For example, in the dot product between two vectors,
240: both vectors must be either Seq or MPI, not one of each
241: */
243: if ((a)->type != (b)->type) SETERRQ2(PETSC_ERR_ARG_NOTSAMETYPE,"Objects not of same type: Argument # %d and %d",arga,argb);
244: /*
245: Use this macro to check if the type is set
246: */
248: if (!(a)->type_name) SETERRQ1(PETSC_ERR_ARG_WRONGSTATE,"Object Type not set: Argument # %d",arg);
249: /*
250: Sometimes object must live on same communicator to inter-operate
251: */
253: {PetscErrorCode _6_ierr,__flag; _6_MPI_Comm_compare(((PetscObject)a)->comm,((PetscObject)b)->comm,&__flag);\
254: CHKERRQ(_6_ierr); \
255: if (__flag != MPI_CONGRUENT && __flag != MPI_IDENT) \
256: SETERRQ2(PETSC_ERR_ARG_NOTSAMECOMM,"Different communicators in the two objects: Argument # %d and %d",arga,argb);}
262: /*
263: All PETSc objects begin with the fields defined in PETSCHEADER.
264: The PetscObject is a way of examining these fields regardless of
265: the specific object. In C++ this could be a base abstract class
266: from which all objects are derived.
267: */
268: struct _p_PetscObject {
269: PETSCHEADER(int)
270: };
272: EXTERN PetscErrorCode PetscObjectPublishBaseBegin(PetscObject);
273: EXTERN PetscErrorCode PetscObjectPublishBaseEnd(PetscObject);
275: EXTERN PetscErrorCode PetscObjectIncreaseState(PetscObject);
276: EXTERN PetscErrorCode PetscObjectGetState(PetscObject,PetscInt*);
277: EXTERN PetscErrorCode PetscRegisterComposedData(PetscInt*);
278: EXTERN PetscErrorCode PetscObjectIncreaseIntComposedData(PetscObject);
279: EXTERN PetscErrorCode PetscObjectIncreaseIntstarComposedData(PetscObject);
280: EXTERN PetscErrorCode PetscObjectIncreaseRealComposedData(PetscObject);
281: EXTERN PetscErrorCode PetscObjectIncreaseRealstarComposedData(PetscObject);
282: EXTERN PetscErrorCode PetscObjectIncreaseScalarComposedData(PetscObject);
283: EXTERN PetscErrorCode PetscObjectIncreaseScalarstarComposedData(PetscObject);
284: EXTERN PetscInt globalcurrentstate,globalmaxstate;
285: /*MC
286: PetscObjectSetIntComposedData - attach integer data to a PetscObject
288: Synopsis:
289: PetscErrorCode PetscObjectSetIntComposedData(PetscObject obj,int id,int data)
291: Not collective
293: Input parameters:
294: + obj - the object to which data is to be attached
295: . id - the identifier for the data
296: - data - the data to be attached
298: Notes:
300: This routine does not return an error code; any errors are handled
301: internally.
303: Level: developer
304: M*/
305: #define PetscObjectSetIntComposedData(obj,id,data) \
306: 0; {PetscErrorCode ierr_; \
307: if ((obj)->int_idmax < globalmaxstate) { \
308: ierr_ = PetscObjectIncreaseIntComposedData(obj); CHKERRQ(ierr_); \
309: } \
310: (obj)->intcomposeddata[id] = data; \
311: (obj)->intcomposedstate[id] = (obj)->state; \
312: }
313: /*MC
314: PetscObjectGetIntComposedData - retrieve integer data attached to an object
316: Synopsis:
317: PetscErrorCode PetscObjectGetIntComposedData(PetscObject obj,int id,int *data,PetscTruth *flag)
319: Not collective
321: Input parameters:
322: + obj - the object from which data is to be retrieved
323: - id - the identifier for the data
325: Output parameters
326: + data - the data to be retrieved
327: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
329: Notes:
331: This routine does not return an error code; any errors are handled
332: internally.
334: The 'data' and 'flag' variables are inlined, so they are not pointers.
336: Level: developer
337: M*/
338: #define PetscObjectGetIntComposedData(obj,id,data,flag) \
339: 0; { \
340: if ((obj)->intcomposedstate) { \
341: if ((obj)->intcomposedstate[id] == (obj)->state) { \
342: data = (obj)->intcomposeddata[id]; \
343: flag = PETSC_TRUE; \
344: } else { \
345: flag = PETSC_FALSE; \
346: } \
347: } else flag = PETSC_FALSE; \
348: }
350: /*MC
351: PetscObjectSetIntstarComposedData - attach integer array data to a PetscObject
353: Synopsis:
354: PetscErrorCode PetscObjectSetIntstarComposedData(PetscObject obj,int id,int *data)
356: Not collective
358: Input parameters:
359: + obj - the object to which data is to be attached
360: . id - the identifier for the data
361: - data - the data to be attached
363: Notes:
365: This routine does not return an error code; any errors are handled
366: internally.
368: Level: developer
369: M*/
370: #define PetscObjectSetIntstarComposedData(obj,id,data) \
371: 0; {PetscErrorCode ierr_; \
372: if ((obj)->intstar_idmax < globalmaxstate) { \
373: ierr_ = PetscObjectIncreaseIntstarComposedData(obj); CHKERRQ(ierr_); \
374: } \
375: (obj)->intstarcomposeddata[id] = data; \
376: (obj)->intstarcomposedstate[id] = (obj)->state; \
377: }
378: /*MC
379: PetscObjectGetIntstarComposedData - retrieve integer array data
380: attached to an object
382: Synopsis:
383: PetscErrorCode PetscObjectGetIntstarComposedData(PetscObject obj,int id,int **data,PetscTruth *flag)
385: Not collective
387: Input parameters:
388: + obj - the object from which data is to be retrieved
389: - id - the identifier for the data
391: Output parameters
392: + data - the data to be retrieved
393: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
395: Notes:
397: This routine does not return an error code; any errors are handled
398: internally.
400: The 'data' and 'flag' variables are inlined, so they are not pointers.
402: Level: developer
403: M*/
404: #define PetscObjectGetIntstarComposedData(obj,id,data,flag) \
405: 0; { \
406: if ((obj)->intstarcomposedstate) { \
407: if ((obj)->intstarcomposedstate[id] == (obj)->state) { \
408: data = (obj)->intstarcomposeddata[id]; \
409: flag = PETSC_TRUE; \
410: } else { \
411: flag = PETSC_FALSE; \
412: } \
413: } else flag = PETSC_FALSE; \
414: }
416: /*MC
417: PetscObjectSetRealComposedData - attach real data to a PetscObject
419: Synopsis:
420: PetscErrorCode PetscObjectSetRealComposedData(PetscObject obj,int id,PetscReal data)
422: Not collective
424: Input parameters:
425: + obj - the object to which data is to be attached
426: . id - the identifier for the data
427: - data - the data to be attached
429: Notes:
431: This routine does not return an error code; any errors are handled
432: internally.
434: Level: developer
435: M*/
436: #define PetscObjectSetRealComposedData(obj,id,data) \
437: 0; {PetscErrorCode ierr_; \
438: if ((obj)->real_idmax < globalmaxstate) { \
439: ierr_ = PetscObjectIncreaseRealComposedData(obj); CHKERRQ(ierr_); \
440: } \
441: (obj)->realcomposeddata[id] = data; \
442: (obj)->realcomposedstate[id] = (obj)->state; \
443: }
444: /*MC
445: PetscObjectGetRealComposedData - retrieve real data attached to an object
447: Synopsis:
448: PetscErrorCode PetscObjectGetRealComposedData(PetscObject obj,int id,PetscReal *data,PetscTruth *flag)
450: Not collective
452: Input parameters:
453: + obj - the object from which data is to be retrieved
454: - id - the identifier for the data
456: Output parameters
457: + data - the data to be retrieved
458: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
460: Notes:
462: This routine does not return an error code; any errors are handled
463: internally.
465: The 'data' and 'flag' variables are inlined, so they are not pointers.
467: Level: developer
468: M*/
469: #define PetscObjectGetRealComposedData(obj,id,data,flag) \
470: 0; { \
471: if ((obj)->realcomposedstate) { \
472: if ((obj)->realcomposedstate[id] == (obj)->state) { \
473: data = (obj)->realcomposeddata[id]; \
474: flag = PETSC_TRUE; \
475: } else { \
476: flag = PETSC_FALSE; \
477: } \
478: } else { \
479: flag = PETSC_FALSE; \
480: } \
481: }
483: /*MC
484: PetscObjectSetRealstarComposedData - attach real array data to a PetscObject
486: Synopsis:
487: PetscErrorCode PetscObjectSetRealstarComposedData(PetscObject obj,int id,PetscReal *data)
489: Not collective
491: Input parameters:
492: + obj - the object to which data is to be attached
493: . id - the identifier for the data
494: - data - the data to be attached
496: Notes:
498: This routine does not return an error code; any errors are handled
499: internally.
501: Level: developer
502: M*/
503: #define PetscObjectSetRealstarComposedData(obj,id,data) \
504: 0; {PetscErrorCode ierr_; \
505: if ((obj)->realstar_idmax < globalmaxstate) { \
506: ierr_ = PetscObjectIncreaseRealstarComposedData(obj); CHKERRQ(ierr_); \
507: } \
508: (obj)->realstarcomposeddata[id] = data; \
509: (obj)->realstarcomposedstate[id] = (obj)->state; \
510: }
511: /*MC
512: PetscObjectGetRealstarComposedData - retrieve real array data
513: attached to an object
515: Synopsis:
516: PetscErrorCode PetscObjectGetRealstarComposedData(PetscObject obj,int id,PetscReal **data,PetscTruth *flag)
518: Not collective
520: Input parameters:
521: + obj - the object from which data is to be retrieved
522: - id - the identifier for the data
524: Output parameters
525: + data - the data to be retrieved
526: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
528: Notes:
530: This routine does not return an error code; any errors are handled
531: internally.
533: The 'data' and 'flag' variables are inlined, so they are not pointers.
535: Level: developer
536: M*/
537: #define PetscObjectGetRealstarComposedData(obj,id,data,flag) \
538: 0; { \
539: if ((obj)->realstarcomposedstate) { \
540: if ((obj)->realstarcomposedstate[id] == (obj)->state) { \
541: data = (obj)->realstarcomposeddata[id]; \
542: flag = PETSC_TRUE; \
543: } else { \
544: flag = PETSC_FALSE; \
545: } \
546: } else { \
547: flag = PETSC_FALSE; \
548: } \
549: }
551: /*MC
552: PetscObjectSetScalarComposedData - attach scalar data to a PetscObject
554: Synopsis:
555: PetscErrorCode PetscObjectSetScalarComposedData(PetscObject obj,int id,PetscScalar data)
557: Not collective
559: Input parameters:
560: + obj - the object to which data is to be attached
561: . id - the identifier for the data
562: - data - the data to be attached
564: Notes:
566: This routine does not return an error code; any errors are handled
567: internally.
569: Level: developer
570: M*/
571: #if defined(PETSC_USE_COMPLEX)
572: #define PetscObjectSetScalarComposedData(obj,id,data) \
573: 0; {PetscErrorCode ierr_; \
574: if ((obj)->scalar_idmax < globalmaxstate) { \
575: ierr_ = PetscObjectIncreaseScalarComposedData(obj); CHKERRQ(ierr_);\
576: } \
577: (obj)->scalarcomposeddata[id] = data; \
578: (obj)->scalarcomposedstate[id] = (obj)->state; \
579: }
580: #else
581: #define PetscObjectSetScalarComposedData(obj,id,data) \
582: PetscObjectSetRealComposedData(obj,id,data)
583: #endif
584: /*MC
585: PetscObjectGetScalarComposedData - retrieve scalar data attached to an object
587: Synopsis:
588: PetscErrorCode PetscObjectGetScalarComposedData(PetscObject obj,int id,PetscScalar *data,PetscTruth *flag)
590: Not collective
592: Input parameters:
593: + obj - the object from which data is to be retrieved
594: - id - the identifier for the data
596: Output parameters
597: + data - the data to be retrieved
598: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
600: Notes:
602: This routine does not return an error code; any errors are handled
603: internally.
605: The 'data' and 'flag' variables are inlined, so they are not pointers.
607: Level: developer
608: M*/
609: #if defined(PETSC_USE_COMPLEX)
610: #define PetscObjectGetScalarComposedData(obj,id,data,flag) \
611: 0; { \
612: if ((obj)->scalarcomposedstate) { \
613: if ((obj)->scalarcomposedstate[id] == (obj)->state) { \
614: data = (obj)->scalarcomposeddata[id]; \
615: flag = PETSC_TRUE; \
616: } else { \
617: flag = PETSC_FALSE; \
618: } \
619: } else flag = PETSC_FALSE; \
620: }
621: #else
622: #define PetscObjectGetScalarComposedData(obj,id,data,flag) \
623: PetscObjectGetRealComposedData(obj,id,data,flag)
624: #endif
626: /*MC
627: PetscObjectSetScalarstarComposedData - attach scalar array data to a PetscObject
629: Synopsis:
630: PetscErrorCode PetscObjectSetScalarstarComposedData(PetscObject obj,int id,PetscScalar *data)
632: Not collective
634: Input parameters:
635: + obj - the object to which data is to be attached
636: . id - the identifier for the data
637: - data - the data to be attached
639: Notes:
641: This routine does not return an error code; any errors are handled
642: internally.
644: Level: developer
645: M*/
646: #if defined(PETSC_USE_COMPLEX)
647: #define PetscObjectSetScalarstarComposedData(obj,id,data) \
648: 0; {PetscErrorCode ierr_; \
649: if ((obj)->scalarstar_idmax < globalmaxstate) { \
650: ierr_ = PetscObjectIncreaseScalarstarComposedData(obj); CHKERRQ(ierr_); \
651: } \
652: (obj)->scalarstarcomposeddata[id] = data; \
653: (obj)->scalarstarcomposedstate[id] = (obj)->state; \
654: }
655: #else
656: #define PetscObjectSetScalarstarComposedData(obj,id,data) \
657: PetscObjectSetRealstarComposedData(obj,id,data)
658: #endif
659: /*MC
660: PetscObjectGetScalarstarComposedData - retrieve scalar array data
661: attached to an object
663: Synopsis:
664: PetscErrorCode PetscObjectGetScalarstarComposedData(PetscObject obj,int id,PetscScalar **data,PetscTruth *flag)
666: Not collective
668: Input parameters:
669: + obj - the object from which data is to be retrieved
670: - id - the identifier for the data
672: Output parameters
673: + data - the data to be retrieved
674: - flag - PETSC_TRUE if the data item exists and is valid, PETSC_FALSE otherwise
676: Notes:
678: This routine does not return an error code; any errors are handled
679: internally.
681: The 'data' and 'flag' variables are inlined, so they are not pointers.
683: Level: developer
684: M*/
685: #if defined(PETSC_USE_COMPLEX)
686: #define PetscObjectGetScalarstarComposedData(obj,id,data,flag) \
687: 0; { \
688: if ((obj)->scalarstarcomposedstate) { \
689: if ((obj)->scalarstarcomposedstate[id] == (obj)->state) { \
690: data = (obj)->scalarstarcomposeddata[id]; \
691: flag = PETSC_TRUE; \
692: } else { \
693: flag = PETSC_FALSE; \
694: } \
695: } else flag = PETSC_FALSE; \
696: }
697: #else
698: #define PetscObjectGetScalarstarComposedData(obj,id,data,flag) \
699: PetscObjectGetRealstarComposedData(obj,id,data,flag)
700: #endif
703: #endif /* _PETSCHEAD_H */