Actual source code: petsc.h

  1: /* $Id: petsc.h,v 1.288 2001/04/13 14:10:22 bsmith Exp $ */
  2: /*
  3:    This is the main PETSc include file (for C and C++).  It is included by all
  4:    other PETSc include files, so it almost never has to be specifically included.
  5: */

  9: /* ========================================================================== */
 10: /* 
 11:    Current PETSc version number and release date
 12: */
 13:  #include petscversion.h

 15: /* ========================================================================== */
 16: /* 
 17:    The PETSc configuration file.  Contains various definitions that
 18:    handle portability issues and the presence of machine features. 

 20:    petscconf.h is contained in bmake/${PETSC_ARCH}/petscconf.h it is 
 21:    found automatically by the compiler due to the -I${PETSC_DIR}/bmake/${PETSC_ARCH}
 22:    in the bmake/common_variables definition of PETSC_INCLUDE
 23: */
 24: #include "petscconf.h"

 26: /* ========================================================================== */

 28: #include <stdio.h>
 29: /*
 30:     Defines the interface to MPI allowing the use of all MPI functions.
 31: */
 32: #include "mpi.h"

 34: /*
 35:     EXTERN indicates a PETSc function defined elsewhere
 36: */
 37: #define EXTERN extern

 39: /*
 40:     Defines some elementary mathematics functions and constants.
 41: */
 42:  #include petscmath.h

 44: /*
 45:        Basic PETSc constants
 46: */

 48: /*E
 49:     PetscTruth - Logical variable. Actually an integer

 51:    Level: beginner

 53: E*/
 54: typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth;

 56: #define PETSC_NULL           0
 57: #define PETSC_DECIDE         -1
 58: #define PETSC_DEFAULT        -2

 60: #define PETSC_YES            PETSC_TRUE
 61: #define PETSC_NO             PETSC_FALSE
 62: #define PETSC_IGNORE         PETSC_NULL
 63: #define PETSC_DETERMINE      PETSC_DECIDE


 66: extern MPI_Comm   PETSC_COMM_WORLD;
 67: extern MPI_Comm   PETSC_COMM_SELF;
 68: extern PetscTruth PetscInitializeCalled;
 69: EXTERN int        PetscSetCommWorld(MPI_Comm);
 70: EXTERN int        PetscSetHelpVersionFunctions(int (*)(MPI_Comm),int (*)(MPI_Comm));

 72: /*MC
 73:    PetscMalloc - Allocates memory

 75:    Input Parameter:
 76: .  m - number of bytes to allocate

 78:    Output Parameter:
 79: .  result - memory allocated

 81:    Synopsis:
 82:    int PetscMalloc(int m,void **result)

 84:    Level: beginner

 86:    Notes: Memory is always allocated at least double aligned

 88: .seealso: PetscFree(), PetscNew()

 90:   Concepts: memory allocation

 92: M*/
 93: /*MC
 94:    PetscNew - Allocates memory of a particular type

 96:    Input Parameter:
 97: . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated

 99:    Output Parameter:
100: .  result - memory allocated

102:    Synopsis:
103:    int PetscNew(struct type,((type *))result)

105:    Level: beginner

107: .seealso: PetscFree(), PetscMalloc()

109:   Concepts: memory allocation

111: M*/
112: #define PetscNew(A,b)        PetscMalloc(sizeof(A),(b))
113: /*MC
114:    PetscFree - Frees memory

116:    Input Parameter:
117: .   memory - memory to free

119:    Synopsis:
120:    int PetscFree(memory)

122:    Level: beginner

124:    Notes: Memory must have been obtained with PetscNew() or PetscMalloc()

126: .seealso: PetscNew(), PetscMalloc()

128:   Concepts: memory allocation

130: M*/
131: EXTERN int  (*PetscTrMalloc)(int,int,char*,char*,char*,void**);
132: EXTERN int  (*PetscTrFree)(void *,int,char*,char*,char*);
133: EXTERN int  PetscSetMalloc(int (*)(int,int,char*,char*,char*,void**),int (*)(void *,int,char*,char*,char*));
134: EXTERN int  PetscClearMalloc(void);

136: /*
137:    Routines for tracing memory corruption/bleeding with default PETSc 
138:    memory allocation
139: */
140: EXTERN int   PetscTrDump(FILE *);
141: EXTERN int   PetscTrSpace(PetscLogDouble *,PetscLogDouble *,PetscLogDouble *);
142: EXTERN int   PetscTrValid(int,const char[],const char[],const char[]);
143: EXTERN int   PetscTrDebugLevel(int);
144: EXTERN int   PetscTrLog(void);
145: EXTERN int   PetscTrLogDump(FILE *);
146: EXTERN int   PetscGetResidentSetSize(PetscLogDouble *);

148: /*
149:     Variable type where we stash PETSc object pointers in Fortran.
150:     Assumes that sizeof(long) == sizeof(void*)which is true on 
151:     all machines that we know.
152: */
153: #define PetscFortranAddr   long

155: /*E
156:     PetscDataType - Used for handling different basic data types.

158:    Level: beginner

160: .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(),
161:           PetscDataTypeGetSize(), PetscDataTypeGetName()

163: E*/
164: typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2,
165:               PETSC_LONG =3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5,
166:               PETSC_CHAR = 6,PETSC_LOGICAL = 7} PetscDataType;
167: #if defined(PETSC_USE_COMPLEX)
168: #define PETSC_SCALAR PETSC_COMPLEX
169: #else
170: #define PETSC_SCALAR PETSC_DOUBLE
171: #endif
172: #if defined(PETSC_USE_SINGLE)
173: #define PETSC_REAL PETSC_FLOAT
174: #else
175: #define PETSC_REAL PETSC_DOUBLE
176: #endif
177: #define PETSC_FORTRANADDR PETSC_LONG

179: EXTERN int PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*);
180: EXTERN int PetscDataTypeGetSize(PetscDataType,int*);
181: EXTERN int PetscDataTypeGetName(PetscDataType,char*[]);

183: /*
184:     Basic memory and string operations. These are usually simple wrappers
185:    around the basic Unix system calls, but a few of them have additional
186:    functionality and/or error checking.
187: */
188: EXTERN int   PetscMemcpy(void *,const void *,int);
189: EXTERN int   PetscBitMemcpy(void*,int,const void*,int,int,PetscDataType);
190: EXTERN int   PetscMemmove(void *,void *,int);
191: EXTERN int   PetscMemzero(void *,int);
192: EXTERN int   PetscMemcmp(const void*,const void*,int,PetscTruth *);
193: EXTERN int   PetscStrlen(const char[],int*);
194: EXTERN int   PetscStrcmp(const char[],const char[],PetscTruth *);
195: EXTERN int   PetscStrgrt(const char[],const char[],PetscTruth *);
196: EXTERN int   PetscStrcasecmp(const char[],const char[],PetscTruth*);
197: EXTERN int   PetscStrncmp(const char[],const char[],int,PetscTruth*);
198: EXTERN int   PetscStrcpy(char[],const char[]);
199: EXTERN int   PetscStrcat(char[],const char[]);
200: EXTERN int   PetscStrncat(char[],const char[],int);
201: EXTERN int   PetscStrncpy(char[],const char[],int);
202: EXTERN int   PetscStrchr(const char[],char,char **);
203: EXTERN int   PetscStrtolower(char[]);
204: EXTERN int   PetscStrrchr(const char[],char,char **);
205: EXTERN int   PetscStrstr(const char[],const char[],char **);
206: EXTERN int   PetscStrtok(const char[],const char[],char **);
207: EXTERN int   PetscStrallocpy(const char[],char **);
208: EXTERN int   PetscStrreplace(MPI_Comm,const char[],char*,int);
209: #define      PetscStrfree(a) ((a) ? PetscFree(a) : 0) 

211: /*
212:    These are  MPI operations for MPI_Allreduce() etc
213: */
214: EXTERN MPI_Op PetscMaxSum_Op;
215: #if defined(PETSC_USE_COMPLEX)
216: EXTERN MPI_Op PetscSum_Op;
217: #else
218: #define PetscSum_Op MPI_SUM
219: #endif

221: /*
222:   Each PETSc object class has it's own cookie (internal integer in the 
223:   data structure used for error checking). These are all defined by an offset 
224:   from the lowest one, PETSC_COOKIE.
225: */
226: #define PETSC_COOKIE                    1211211
227: #define PETSC_MAX_COOKIES               60
228: #define PETSC_LARGEST_COOKIE_PREDEFINED PETSC_COOKIE + 30
229: #define PETSC_LARGEST_COOKIE_ALLOWED    PETSC_COOKIE + PETSC_MAX_COOKIES
230: extern int PETSC_LARGEST_COOKIE;

232: /*S
233:      PetscObject - any PETSc object, PetscViewer, Mat, Vec, SLES etc

235:    Level: beginner

237: .seealso:  PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName()
238: S*/
239: typedef struct _p_PetscObject* PetscObject;

241: /*S
242:      PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed
243:       by string name

245:    Level: advanced

247: .seealso:  PetscFListAdd(), PetscFListDestroy()
248: S*/
249: typedef struct _PetscFList *PetscFList;

251:  #include petscviewer.h
252:  #include petscoptions.h

254: EXTERN int PetscShowMemoryUsage(PetscViewer,char*);
255: EXTERN int PetscGetTime(PetscLogDouble*);
256: EXTERN int PetscGetCPUTime(PetscLogDouble*);
257: EXTERN int PetscSleep(int);

259: /*
260:     Initialization of PETSc
261: */
262: EXTERN int  PetscInitialize(int*,char***,char[],const char[]);
263: EXTERN int  PetscInitializeNoArguments(void);
264: EXTERN int  PetscFinalize(void);
265: EXTERN int  PetscInitializeFortran(void);

267: /*
268:     Functions that can act on any PETSc object.
269: */
270: EXTERN int PetscObjectDestroy(PetscObject);
271: EXTERN int PetscObjectExists(PetscObject,PetscTruth*);
272: EXTERN int PetscObjectGetComm(PetscObject,MPI_Comm *);
273: EXTERN int PetscObjectGetCookie(PetscObject,int *);
274: EXTERN int PetscObjectGetType(PetscObject,int *);
275: EXTERN int PetscObjectSetName(PetscObject,const char[]);
276: EXTERN int PetscObjectGetName(PetscObject,char*[]);
277: EXTERN int PetscObjectReference(PetscObject);
278: EXTERN int PetscObjectGetReference(PetscObject,int*);
279: EXTERN int PetscObjectDereference(PetscObject);
280: EXTERN int PetscObjectGetNewTag(PetscObject,int *);
281: EXTERN int PetscCommGetNewTag(MPI_Comm,int *);
282: EXTERN int PetscObjectView(PetscObject,PetscViewer);
283: EXTERN int PetscObjectCompose(PetscObject,const char[],PetscObject);
284: EXTERN int PetscObjectQuery(PetscObject,const char[],PetscObject *);
285: EXTERN int PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)());
286: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
287: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0)
288: #else
289: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(void (*)())(d))
290: #endif
291: EXTERN int PetscObjectQueryFunction(PetscObject,const char[],void (**)());
292: EXTERN int PetscObjectSetOptionsPrefix(PetscObject,const char[]);
293: EXTERN int PetscObjectAppendOptionsPrefix(PetscObject,const char[]);
294: EXTERN int PetscObjectPrependOptionsPrefix(PetscObject,const char[]);
295: EXTERN int PetscObjectGetOptionsPrefix(PetscObject,char*[]);
296: EXTERN int PetscObjectPublish(PetscObject);
297: EXTERN int PetscObjectChangeTypeName(PetscObject,char *);
298: EXTERN int PetscObjectRegisterDestroy(PetscObject);
299: EXTERN int PetscObjectRegisterDestroyAll(void);
300: EXTERN int PetscObjectName(PetscObject);
301: EXTERN int PetscTypeCompare(PetscObject,char*,PetscTruth*);

303: /*
304:     Defines PETSc error handling.
305: */
306:  #include petscerror.h

308: /*S
309:      PetscOList - Linked list of PETSc objects, accessable by string name

311:    Level: advanced

313: .seealso:  PetscOListAdd(), PetscOListDestroy(), PetscOListFind()
314: S*/
315: typedef struct _PetscOList *PetscOList;

317: EXTERN int PetscOListDestroy(PetscOList *);
318: EXTERN int PetscOListFind(PetscOList,const char[],PetscObject*);
319: EXTERN int PetscOListReverseFind(PetscOList,PetscObject,char**);
320: EXTERN int PetscOListAdd(PetscOList *,const char[],PetscObject);
321: EXTERN int PetscOListDuplicate(PetscOList,PetscOList *);

323: /*
324:     Dynamic library lists. Lists of names of routines in dynamic 
325:   link libraries that will be loaded as needed.
326: */
327: EXTERN int PetscFListAdd(PetscFList*,const char[],const char[],void (*)());
328: EXTERN int PetscFListDestroy(PetscFList*);
329: EXTERN int PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)());
330: EXTERN int PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],char *,char *,PetscFList);
331: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
332: #define    PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0)
333: #else
334: #define    PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)())c)
335: #endif
336: EXTERN int PetscFListDuplicate(PetscFList,PetscFList *);
337: EXTERN int PetscFListView(PetscFList,PetscViewer);
338: EXTERN int PetscFListConcat(const char [],const char [],char []);
339: EXTERN int PetscFListGet(PetscFList,char ***,int*);

341: /*S
342:      PetscDLLibraryList - Linked list of dynamics libraries to search for functions

344:    Level: advanced

346:    PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries

348: .seealso:  PetscDLLibraryOpen()
349: S*/
350: typedef struct _PetscDLLibraryList *PetscDLLibraryList;
351: extern PetscDLLibraryList DLLibrariesLoaded;
352: EXTERN int PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *);
353: EXTERN int PetscDLLibraryOpen(MPI_Comm,const char[],void **);
354: EXTERN int PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **);
355: EXTERN int PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]);
356: EXTERN int PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]);
357: EXTERN int PetscDLLibraryClose(PetscDLLibraryList);
358: EXTERN int PetscDLLibraryPrintPath(void);
359: EXTERN int PetscDLLibraryGetInfo(void *,char *,char **);

361: /*
362:     Mechanism for translating PETSc object representations between languages
363:     Not currently used.
364: */
365: typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage;
366: #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C
367: EXTERN int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *);
368: EXTERN int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **);

370: /*
371:      Useful utility routines
372: */
373: EXTERN int PetscSplitOwnership(MPI_Comm,int*,int*);
374: EXTERN int PetscSplitOwnershipBlock(MPI_Comm,int,int*,int*);
375: EXTERN int PetscSequentialPhaseBegin(MPI_Comm,int);
376: EXTERN int PetscSequentialPhaseEnd(MPI_Comm,int);
377: EXTERN int PetscBarrier(PetscObject);
378: EXTERN int PetscMPIDump(FILE*);

380: #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE)
381: /*
382:     Defines basic graphics available from PETSc.
383: */
384:  #include petscdraw.h

386: /*
387:     Defines the base data structures for all PETSc objects
388: */
389:  #include petschead.h

391: /*
392:      Defines PETSc profiling.
393: */
394:  #include petsclog.h

396: /*
397:           For locking, unlocking and destroying AMS memories associated with 
398:     PETSc objects
399: */
400: #if defined(PETSC_HAVE_AMS)

402: extern PetscTruth PetscAMSPublishAll;
403: #define PetscPublishAll(v) (PetscAMSPublishAll ? PetscObjectPublish((PetscObject)v) : 0)
404: #define PetscObjectTakeAccess(obj)  ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_take_access(((PetscObject)(obj))->amem))
405: #define PetscObjectGrantAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_grant_access(((PetscObject)(obj))->amem))
406: #define PetscObjectDepublish(obj)   ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_destroy(((PetscObject)(obj))->amem)); 
407:     ((PetscObject)(obj))->amem = -1;

409: #else

411: #define PetscPublishAll(v)           0
412: #define PetscObjectTakeAccess(obj)   0
413: #define PetscObjectGrantAccess(obj)  0
414: #define PetscObjectDepublish(obj)      0

416: #endif



420: /*
421:       This code allows one to pass a MPI communicator between 
422:     C and Fortran. MPI 2.0 defines a standard API for doing this.
423:     The code here is provided to allow PETSc to work with MPI 1.1
424:     standard MPI libraries.
425: */
426: EXTERN int  MPICCommToFortranComm(MPI_Comm,int *);
427: EXTERN int  MPIFortranCommToCComm(int,MPI_Comm*);

429: /*
430:       Simple PETSc parallel IO for ASCII printing
431: */
432: EXTERN int  PetscFixFilename(const char[],char[]);
433: EXTERN int  PetscFOpen(MPI_Comm,const char[],const char[],FILE**);
434: EXTERN int  PetscFClose(MPI_Comm,FILE*);
435: EXTERN int  PetscFPrintf(MPI_Comm,FILE*,const char[],...);
436: EXTERN int  PetscPrintf(MPI_Comm,const char[],...);
437: EXTERN int  (*PetscErrorPrintf)(const char[],...);
438: EXTERN int  (*PetscHelpPrintf)(MPI_Comm,const char[],...);
439: EXTERN int  PetscPOpen(MPI_Comm,char *,char*,const char[],FILE **);
440: EXTERN int  PetscPClose(MPI_Comm,FILE*);
441: EXTERN int  PetscSynchronizedPrintf(MPI_Comm,const char[],...);
442: EXTERN int  PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...);
443: EXTERN int  PetscSynchronizedFlush(MPI_Comm);
444: EXTERN int  PetscSynchronizedFGets(MPI_Comm,FILE*,int,char[]);
445: EXTERN int  PetscStartMatlab(MPI_Comm,char *,char*,FILE**);
446: EXTERN int  PetscStartJava(MPI_Comm,char *,char*,FILE**);

448: EXTERN int  PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*);
449: /*S
450:      PetscObjectContainer - Simple PETSc object that contains a pointer to any required data

452:    Level: advanced

454: .seealso:  PetscObject, PetscObjectContainerCreate()
455: S*/
456: typedef struct _p_PetscObjectContainer*  PetscObjectContainer;
457: EXTERN int PetscObjectContainerGetPointer(PetscObjectContainer,void **);
458: EXTERN int PetscObjectContainerSetPointer(PetscObjectContainer,void *);
459: EXTERN int PetscObjectContainerDestroy(PetscObjectContainer);
460: EXTERN int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *);

462: /*
463:    For incremental debugging
464: */
465: extern PetscTruth PetscCompare;
466: EXTERN int        PetscCompareDouble(double);
467: EXTERN int        PetscCompareScalar(Scalar);
468: EXTERN int        PetscCompareInt(int);

470: /*
471:    For use in debuggers 
472: */
473: extern int PetscGlobalRank,PetscGlobalSize;
474: EXTERN int PetscIntView(int,int[],PetscViewer);
475: EXTERN int PetscDoubleView(int,double[],PetscViewer);
476: EXTERN int PetscScalarView(int,Scalar[],PetscViewer);

478: /*
479:     Allows accessing Matlab Engine
480: */
481:  #include petscengine.h

483: /*
484:     C code optimization is often enhanced by telling the compiler 
485:   that certain pointer arguments to functions are not aliased to 
486:   to other arguments. This is not yet ANSI C standard so we define 
487:   the macro "restrict" to indicate that the variable is not aliased 
488:   to any other argument.
489: */
490: #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus)
491: #define restrict _Restrict
492: #else
493: #define restrict
494: #endif

496: /*
497:       Determine if some of the kernel computation routines use
498:    Fortran (rather than C) for the numerical calculations. On some machines
499:    and compilers (like complex numbers) the Fortran version of the routines
500:    is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS  
501:    would be set in the petscconf.h file
502: */
503: #if defined(PETSC_USE_FORTRAN_KERNELS)

505: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ)
506: #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ
507: #endif

509: #if !defined(PETSC_USE_FORTRAN_KERNEL_NORMSQR)
510: #define PETSC_USE_FORTRAN_KERNEL_NORMSQR
511: #endif

513: #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY)
514: #define PETSC_USE_FORTRAN_KERNEL_MAXPY
515: #endif

517: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ)
518: #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ
519: #endif

521: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ)
522: #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ
523: #endif

525: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ)
526: #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ
527: #endif

529: #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT)
530: #define PETSC_USE_FORTRAN_KERNEL_MDOT
531: #endif

533: #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY)
534: #define PETSC_USE_FORTRAN_KERNEL_XTIMESY
535: #endif

537: #endif

539: /*
540:     Macros for indicating code that should be compiled with a C interface,
541:    rather than a C++ interface. Any routines that are dynamically loaded
542:    (such as the PCCreate_XXX() routines) must be wrapped so that the name
543:    mangler does not change the functions symbol name. This just hides the 
544:    ugly extern "C" {} wrappers.
545: */
546: #if defined(__cplusplus)
547: #define EXTERN_C_BEGIN extern "C" {
548: #define EXTERN_C_END }
549: #else
550: #define EXTERN_C_BEGIN 
551: #define EXTERN_C_END 
552: #endif

554: /* --------------------------------------------------------------------*/
555: /*
556:     DVF (win32) uses STDCALL calling convention by default.
557:     The following is used by the fortran interface.
558: */
559: #if defined (PETSC_USE_FORTRAN_STDCALL)
560: #define PETSC_STDCALL __stdcall
561: #else
562: #define PETSC_STDCALL 
563: #endif

565: #endif

567: /*M
568:     size - integer variable used to contain the number of processors in
569:            the relevent MPI_Comm

571:    Level: beginner

573: .seealso: rank, comm
574: M*/

576: /*M
577:     rank - integer variable used to contain the number of this processor relative
578:            to all in the relevent MPI_Comm

580:    Level: beginner

582: .seealso: size, comm
583: M*/

585: /*M
586:     comm - MPI_Comm used in the current routine or object

588:    Level: beginner

590: .seealso: size, rank
591: M*/

593: /*M
594:     Scalar - PETSc type that represents either a double precision real number or 
595:        a double precision complex number if the code is compiled with BOPT=g_complex or O_complex

597:    Level: beginner

599: M*/

601: /*
602:      The IBM include files define hz, here we hide it so that it may be used
603:    as a regular user variable.
604: */
605: #if defined(hz)
606: #undef hz
607: #endif