Actual source code: petsc.h

  1: /* $Id: petsc.h,v 1.297 2001/09/07 20:13:16 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:    petscconf.h is contained in bmake/${PETSC_ARCH}/petscconf.h it is 
 18:    found automatically by the compiler due to the -I${PETSC_DIR}/bmake/${PETSC_ARCH}
 19:    in the bmake/common_variables definition of PETSC_INCLUDE
 20: */
 21: #include "petscconf.h"
 22: /*
 23:    Fixes for configure time choices which impact our interface. Currently only
 24:    calling conventions and extra compiler checking falls under this category.
 25: */
 26: #if !defined(PETSC_PRINTF_FORMAT_CHECK)
 27: #define PETSC_PRINTF_FORMAT_CHECK(a,b)
 28: #endif
 29: #if !defined (PETSC_STDCALL)
 30: #define PETSC_STDCALL
 31: #endif
 32: #if !defined (PETSC_TEMPLATE)
 33: #define PETSC_TEMPLATE
 34: #endif

 36: /* ========================================================================== */

 38: #include <stdio.h>
 39: /*
 40:     Defines the interface to MPI allowing the use of all MPI functions.
 41: */
 42: #include "mpi.h"

 44: /*
 45:     EXTERN indicates a PETSc function defined elsewhere
 46: */
 47: #define EXTERN extern

 49: /*
 50:     Defines some elementary mathematics functions and constants.
 51: */
 52:  #include petscmath.h

 54: /*
 55:        Basic PETSc constants
 56: */

 58: /*E
 59:     PetscTruth - Logical variable. Actually an integer

 61:    Level: beginner

 63: E*/
 64: typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth;

 66: #define PETSC_NULL           0
 67: #define PETSC_DECIDE         -1
 68: #define PETSC_DEFAULT        -2

 70: #define PETSC_YES            PETSC_TRUE
 71: #define PETSC_NO             PETSC_FALSE
 72: #define PETSC_IGNORE         PETSC_NULL
 73: #define PETSC_DETERMINE      PETSC_DECIDE


 76: extern MPI_Comm   PETSC_COMM_WORLD;
 77: extern MPI_Comm   PETSC_COMM_SELF;
 78: extern PetscTruth PetscInitializeCalled;
 79: EXTERN int        PetscSetCommWorld(MPI_Comm);
 80: EXTERN int        PetscSetHelpVersionFunctions(int (*)(MPI_Comm),int (*)(MPI_Comm));

 82: /*MC
 83:    PetscMalloc - Allocates memory

 85:    Input Parameter:
 86: .  m - number of bytes to allocate

 88:    Output Parameter:
 89: .  result - memory allocated

 91:    Synopsis:
 92:    int PetscMalloc(int m,void **result)

 94:    Level: beginner

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

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

100:   Concepts: memory allocation

102: M*/
103: /*MC
104:    PetscNew - Allocates memory of a particular type

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

109:    Output Parameter:
110: .  result - memory allocated

112:    Synopsis:
113:    int PetscNew(struct type,((type *))result)

115:    Level: beginner

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

119:   Concepts: memory allocation

121: M*/
122: #define PetscNew(A,b)        PetscMalloc(sizeof(A),(b))
123: /*MC
124:    PetscFree - Frees memory

126:    Input Parameter:
127: .   memory - memory to free

129:    Synopsis:
130:    int PetscFree(void *memory)

132:    Level: beginner

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

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

138:   Concepts: memory allocation

140: M*/
141: EXTERN int  (*PetscTrMalloc)(int,int,char*,char*,char*,void**);
142: EXTERN int  (*PetscTrFree)(void *,int,char*,char*,char*);
143: EXTERN int  PetscSetMalloc(int (*)(int,int,char*,char*,char*,void**),int (*)(void *,int,char*,char*,char*));
144: EXTERN int  PetscClearMalloc(void);

146: /*
147:    Routines for tracing memory corruption/bleeding with default PETSc 
148:    memory allocation
149: */
150: EXTERN int   PetscTrDump(FILE *);
151: EXTERN int   PetscTrSpace(PetscLogDouble *,PetscLogDouble *,PetscLogDouble *);
152: EXTERN int   PetscTrValid(int,const char[],const char[],const char[]);
153: EXTERN int   PetscTrDebugLevel(int);
154: EXTERN int   PetscTrLog(void);
155: EXTERN int   PetscTrLogDump(FILE *);
156: EXTERN int   PetscGetResidentSetSize(PetscLogDouble *);

158: /*
159:     Variable type where we stash PETSc object pointers in Fortran.
160:     Assumes that sizeof(long) == sizeof(void*)which is true on 
161:     all machines that we know.
162: */
163: #define PetscFortranAddr   long

165: /*E
166:     PetscDataType - Used for handling different basic data types.

168:    Level: beginner

170: .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(),
171:           PetscDataTypeGetSize(), PetscDataTypeGetName()

173: E*/
174: typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2,
175:               PETSC_LONG =3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5,
176:               PETSC_CHAR = 6,PETSC_LOGICAL = 7} PetscDataType;
177: #if defined(PETSC_USE_COMPLEX)
178: #define PETSC_SCALAR PETSC_COMPLEX
179: #else
180: #if defined(PETSC_USE_SINGLE)
181: #define PETSC_SCALAR PETSC_FLOAT
182: #else
183: #define PETSC_SCALAR PETSC_DOUBLE
184: #endif
185: #endif
186: #if defined(PETSC_USE_SINGLE)
187: #define PETSC_REAL PETSC_FLOAT
188: #else
189: #define PETSC_REAL PETSC_DOUBLE
190: #endif
191: #define PETSC_FORTRANADDR PETSC_LONG

193: EXTERN int PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*);
194: EXTERN int PetscDataTypeGetSize(PetscDataType,int*);
195: EXTERN int PetscDataTypeGetName(PetscDataType,char*[]);

197: /*
198:     Basic memory and string operations. These are usually simple wrappers
199:    around the basic Unix system calls, but a few of them have additional
200:    functionality and/or error checking.
201: */
202: EXTERN int   PetscMemcpy(void *,const void *,int);
203: EXTERN int   PetscBitMemcpy(void*,int,const void*,int,int,PetscDataType);
204: EXTERN int   PetscMemmove(void *,void *,int);
205: EXTERN int   PetscMemzero(void *,int);
206: EXTERN int   PetscMemcmp(const void*,const void*,int,PetscTruth *);
207: EXTERN int   PetscStrlen(const char[],int*);
208: EXTERN int   PetscStrcmp(const char[],const char[],PetscTruth *);
209: EXTERN int   PetscStrgrt(const char[],const char[],PetscTruth *);
210: EXTERN int   PetscStrcasecmp(const char[],const char[],PetscTruth*);
211: EXTERN int   PetscStrncmp(const char[],const char[],int,PetscTruth*);
212: EXTERN int   PetscStrcpy(char[],const char[]);
213: EXTERN int   PetscStrcat(char[],const char[]);
214: EXTERN int   PetscStrncat(char[],const char[],int);
215: EXTERN int   PetscStrncpy(char[],const char[],int);
216: EXTERN int   PetscStrchr(const char[],char,char **);
217: EXTERN int   PetscStrtolower(char[]);
218: EXTERN int   PetscStrrchr(const char[],char,char **);
219: EXTERN int   PetscStrstr(const char[],const char[],char **);
220: EXTERN int   PetscStrallocpy(const char[],char **);
221: EXTERN int   PetscStrreplace(MPI_Comm,const char[],char*,int);
222: #define      PetscStrfree(a) ((a) ? PetscFree(a) : 0) 
223: typedef struct {char token;char *array;char *current;} PetscToken;
224: EXTERN int   PetscTokenCreate(const char[],const char,PetscToken**);
225: EXTERN int   PetscTokenFind(PetscToken*,char **);
226: EXTERN int   PetscTokenDestroy(PetscToken*);

228: /*
229:    These are  MPI operations for MPI_Allreduce() etc
230: */
231: EXTERN MPI_Op PetscMaxSum_Op;
232: #if defined(PETSC_USE_COMPLEX)
233: EXTERN MPI_Op PetscSum_Op;
234: #else
235: #define PetscSum_Op MPI_SUM
236: #endif

238: /*S
239:      PetscObject - any PETSc object, PetscViewer, Mat, Vec, SLES etc

241:    Level: beginner

243: .seealso:  PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName()
244: S*/
245: typedef struct _p_PetscObject* PetscObject;

247: /*S
248:      PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed
249:       by string name

251:    Level: advanced

253: .seealso:  PetscFListAdd(), PetscFListDestroy()
254: S*/
255: typedef struct _PetscFList *PetscFList;

257:  #include petscviewer.h
258:  #include petscoptions.h

260: EXTERN int PetscShowMemoryUsage(PetscViewer,char*);
261: EXTERN int PetscGetTime(PetscLogDouble*);
262: EXTERN int PetscGetCPUTime(PetscLogDouble*);
263: EXTERN int PetscSleep(int);

265: /*
266:     Initialization of PETSc
267: */
268: EXTERN int  PetscInitialize(int*,char***,char[],const char[]);
269: EXTERN int  PetscInitializeNoArguments(void);
270: EXTERN int  PetscFinalize(void);
271: EXTERN int  PetscInitializeFortran(void);
272: EXTERN int  PetscGetArgs(int*,char ***);
273: EXTERN int  PetscEnd(void);

275: /*
276:    ParameterDict is an abstraction for arguments to interface mechanisms
277: */
278: extern int DICT_COOKIE;
279: typedef struct _p_Dict *ParameterDict;

281: typedef void (**PetscVoidFunction)(void);

283: /*
284:    PetscTryMethod - Queries an object for a method, if it exists then calls it.
285:           Can support argument checking 
286: */
287: #if defined(PETSC_FORTRAN_STUBS)
288: #define  PetscTryMethod(obj,A,B,C) 
289:   0;{ int (*f)B; 
290:    *PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);if (*ierr) return; 
291:     if (f) {*(*f)C;if (*ierr) return;}
292:   }
293: #else
294: #define  PetscTryMethod(obj,A,B,C) 
295:   0;{ int (*f)B, __ierr; 
296:     __PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);CHKERRQ(__ierr); 
297:     if (f) {__(*f)C;CHKERRQ(__ierr);}
298:   }
299: #endif

301: /*
302:     Functions that can act on any PETSc object.
303: */
304: EXTERN int PetscObjectDestroy(PetscObject);
305: EXTERN int PetscObjectExists(PetscObject,PetscTruth*);
306: EXTERN int PetscObjectGetComm(PetscObject,MPI_Comm *);
307: EXTERN int PetscObjectGetCookie(PetscObject,int *);
308: EXTERN int PetscObjectGetType(PetscObject,int *);
309: EXTERN int PetscObjectSetName(PetscObject,const char[]);
310: EXTERN int PetscObjectGetName(PetscObject,char*[]);
311: EXTERN int PetscObjectReference(PetscObject);
312: EXTERN int PetscObjectGetReference(PetscObject,int*);
313: EXTERN int PetscObjectDereference(PetscObject);
314: EXTERN int PetscObjectGetNewTag(PetscObject,int *);
315: EXTERN int PetscObjectSetParameterDict(PetscObject,ParameterDict);
316: EXTERN int PetscObjectGetParameterDict(PetscObject,ParameterDict*);
317: EXTERN int PetscCommGetNewTag(MPI_Comm,int *);
318: EXTERN int PetscObjectView(PetscObject,PetscViewer);
319: EXTERN int PetscObjectCompose(PetscObject,const char[],PetscObject);
320: EXTERN int PetscObjectQuery(PetscObject,const char[],PetscObject *);
321: EXTERN int PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)(void));
322: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
323: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0)
324: #else
325: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(void (*)(void))(d))
326: #endif
327: EXTERN int PetscObjectQueryFunction(PetscObject,const char[],void (**)(void));
328: EXTERN int PetscObjectSetOptionsPrefix(PetscObject,const char[]);
329: EXTERN int PetscObjectAppendOptionsPrefix(PetscObject,const char[]);
330: EXTERN int PetscObjectPrependOptionsPrefix(PetscObject,const char[]);
331: EXTERN int PetscObjectGetOptionsPrefix(PetscObject,char*[]);
332: EXTERN int PetscObjectPublish(PetscObject);
333: EXTERN int PetscObjectChangeTypeName(PetscObject,char *);
334: EXTERN int PetscObjectChangeSerializeName(PetscObject,char *);
335: EXTERN int PetscObjectRegisterDestroy(PetscObject);
336: EXTERN int PetscObjectRegisterDestroyAll(void);
337: EXTERN int PetscObjectName(PetscObject);
338: EXTERN int PetscTypeCompare(PetscObject,char*,PetscTruth*);
339: EXTERN int PetscSerializeCompare(PetscObject,char*,PetscTruth*);

341: /*
342:     Defines PETSc error handling.
343: */
344:  #include petscerror.h

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

349:    Level: advanced

351: .seealso:  PetscOListAdd(), PetscOListDestroy(), PetscOListFind()
352: S*/
353: typedef struct _PetscOList *PetscOList;

355: EXTERN int PetscOListDestroy(PetscOList *);
356: EXTERN int PetscOListFind(PetscOList,const char[],PetscObject*);
357: EXTERN int PetscOListReverseFind(PetscOList,PetscObject,char**);
358: EXTERN int PetscOListAdd(PetscOList *,const char[],PetscObject);
359: EXTERN int PetscOListDuplicate(PetscOList,PetscOList *);

361: /*
362:     Dynamic library lists. Lists of names of routines in dynamic 
363:   link libraries that will be loaded as needed.
364: */
365: EXTERN int PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void));
366: EXTERN int PetscFListDestroy(PetscFList*);
367: EXTERN int PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)(void));
368: EXTERN int PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],char *,char *,PetscFList);
369: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
370: #define    PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0)
371: #else
372: #define    PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c)
373: #endif
374: EXTERN int PetscFListDuplicate(PetscFList,PetscFList *);
375: EXTERN int PetscFListView(PetscFList,PetscViewer);
376: EXTERN int PetscFListConcat(const char [],const char [],char []);
377: EXTERN int PetscFListGet(PetscFList,char ***,int*);

379: /*S
380:      PetscDLLibraryList - Linked list of dynamics libraries to search for functions

382:    Level: advanced

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

386: .seealso:  PetscDLLibraryOpen()
387: S*/
388: typedef struct _PetscDLLibraryList *PetscDLLibraryList;
389: extern PetscDLLibraryList DLLibrariesLoaded;
390: EXTERN int PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *);
391: EXTERN int PetscDLLibraryOpen(MPI_Comm,const char[],void **);
392: EXTERN int PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **);
393: EXTERN int PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]);
394: EXTERN int PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]);
395: EXTERN int PetscDLLibraryClose(PetscDLLibraryList);
396: EXTERN int PetscDLLibraryPrintPath(void);
397: EXTERN int PetscDLLibraryGetInfo(void *,char *,char **);

399: /*
400:     Mechanism for translating PETSc object representations between languages
401:     Not currently used.
402: */
403: typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage;
404: #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C
405: EXTERN int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *);
406: EXTERN int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **);

408: /*
409:      Useful utility routines
410: */
411: EXTERN int PetscSplitOwnership(MPI_Comm,int*,int*);
412: EXTERN int PetscSplitOwnershipBlock(MPI_Comm,int,int*,int*);
413: EXTERN int PetscSequentialPhaseBegin(MPI_Comm,int);
414: EXTERN int PetscSequentialPhaseEnd(MPI_Comm,int);
415: EXTERN int PetscBarrier(PetscObject);
416: EXTERN int PetscMPIDump(FILE*);

418: #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE)
419: /*
420:     Defines basic graphics available from PETSc.
421: */
422:  #include petscdraw.h

424: /*
425:     Defines the base data structures for all PETSc objects
426: */
427:  #include petschead.h

429: /*
430:      Defines PETSc profiling.
431: */
432:  #include petsclog.h

434: /*
435:           For locking, unlocking and destroying AMS memories associated with 
436:     PETSc objects
437: */
438: #if defined(PETSC_HAVE_AMS)

440: extern PetscTruth PetscAMSPublishAll;
441: #define PetscPublishAll(v) (PetscAMSPublishAll ? PetscObjectPublish((PetscObject)v) : 0)
442: #define PetscObjectTakeAccess(obj)  ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_take_access(((PetscObject)(obj))->amem))
443: #define PetscObjectGrantAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_grant_access(((PetscObject)(obj))->amem))
444: #define PetscObjectDepublish(obj)   ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_destroy(((PetscObject)(obj))->amem)); 
445:     ((PetscObject)(obj))->amem = -1;

447: #else

449: #define PetscPublishAll(v)           0
450: #define PetscObjectTakeAccess(obj)   0
451: #define PetscObjectGrantAccess(obj)  0
452: #define PetscObjectDepublish(obj)      0

454: #endif



458: /*
459:       This code allows one to pass a MPI communicator between 
460:     C and Fortran. MPI 2.0 defines a standard API for doing this.
461:     The code here is provided to allow PETSc to work with MPI 1.1
462:     standard MPI libraries.
463: */
464: EXTERN int  MPICCommToFortranComm(MPI_Comm,int *);
465: EXTERN int  MPIFortranCommToCComm(int,MPI_Comm*);

467: /*
468:       Simple PETSc parallel IO for ASCII printing
469: */
470: EXTERN int  PetscFixFilename(const char[],char[]);
471: EXTERN int  PetscFOpen(MPI_Comm,const char[],const char[],FILE**);
472: EXTERN int  PetscFClose(MPI_Comm,FILE*);
473: EXTERN int  PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4);
474: EXTERN int  PetscPrintf(MPI_Comm,const char[],...)  PETSC_PRINTF_FORMAT_CHECK(2,3);
475: EXTERN int  (*PetscErrorPrintf)(const char[],...);
476: EXTERN int  (*PetscHelpPrintf)(MPI_Comm,const char[],...);
477: EXTERN int  PetscPOpen(MPI_Comm,char *,char*,const char[],FILE **);
478: EXTERN int  PetscPClose(MPI_Comm,FILE*);
479: EXTERN int  PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3);
480: EXTERN int  PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4);
481: EXTERN int  PetscSynchronizedFlush(MPI_Comm);
482: EXTERN int  PetscSynchronizedFGets(MPI_Comm,FILE*,int,char[]);
483: EXTERN int  PetscStartMatlab(MPI_Comm,char *,char*,FILE**);
484: EXTERN int  PetscStartJava(MPI_Comm,char *,char*,FILE**);
485: EXTERN int  PetscGetPetscDir(char**);

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

491:    Level: advanced

493: .seealso:  PetscObject, PetscObjectContainerCreate()
494: S*/
495: typedef struct _p_PetscObjectContainer*  PetscObjectContainer;
496: EXTERN int PetscObjectContainerGetPointer(PetscObjectContainer,void **);
497: EXTERN int PetscObjectContainerSetPointer(PetscObjectContainer,void *);
498: EXTERN int PetscObjectContainerDestroy(PetscObjectContainer);
499: EXTERN int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *);

501: /*
502:    For incremental debugging
503: */
504: extern PetscTruth PetscCompare;
505: EXTERN int        PetscCompareDouble(double);
506: EXTERN int        PetscCompareScalar(PetscScalar);
507: EXTERN int        PetscCompareInt(int);

509: /*
510:    For use in debuggers 
511: */
512: extern int PetscGlobalRank,PetscGlobalSize;
513: EXTERN int PetscIntView(int,int[],PetscViewer);
514: EXTERN int PetscRealView(int,PetscReal[],PetscViewer);
515: EXTERN int PetscScalarView(int,PetscScalar[],PetscViewer);

517: /*
518:     Allows accessing Matlab Engine
519: */
520:  #include petscengine.h

522: /*
523:     C code optimization is often enhanced by telling the compiler 
524:   that certain pointer arguments to functions are not aliased to 
525:   to other arguments. This is not yet ANSI C standard so we define 
526:   the macro "restrict" to indicate that the variable is not aliased 
527:   to any other argument.
528: */
529: #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus)
530: #define restrict _Restrict
531: #else
532: #if defined(restrict)
533: #undef restrict
534: #endif
535: #define restrict
536: #endif

538: /*
539:       Determine if some of the kernel computation routines use
540:    Fortran (rather than C) for the numerical calculations. On some machines
541:    and compilers (like complex numbers) the Fortran version of the routines
542:    is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS  
543:    would be set in the petscconf.h file
544: */
545: #if defined(PETSC_USE_FORTRAN_KERNELS)

547: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ)
548: #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ
549: #endif

551: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ)
552: #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ
553: #endif

555: #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM)
556: #define PETSC_USE_FORTRAN_KERNEL_NORM
557: #endif

559: #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY)
560: #define PETSC_USE_FORTRAN_KERNEL_MAXPY
561: #endif

563: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ)
564: #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ
565: #endif

567: #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ)
568: #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ
569: #endif

571: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ)
572: #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ
573: #endif

575: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ)
576: #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ
577: #endif

579: #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT)
580: #define PETSC_USE_FORTRAN_KERNEL_MDOT
581: #endif

583: #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY)
584: #define PETSC_USE_FORTRAN_KERNEL_XTIMESY
585: #endif

587: #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX)
588: #define PETSC_USE_FORTRAN_KERNEL_AYPX
589: #endif

591: #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY)
592: #define PETSC_USE_FORTRAN_KERNEL_WAXPY
593: #endif

595: #endif

597: /*
598:     Macros for indicating code that should be compiled with a C interface,
599:    rather than a C++ interface. Any routines that are dynamically loaded
600:    (such as the PCCreate_XXX() routines) must be wrapped so that the name
601:    mangler does not change the functions symbol name. This just hides the 
602:    ugly extern "C" {} wrappers.
603: */
604: #if defined(__cplusplus)
605: #define EXTERN_C_BEGIN extern "C" {
606: #define EXTERN_C_END }
607: #else
608: #define EXTERN_C_BEGIN 
609: #define EXTERN_C_END 
610: #endif

612: /* --------------------------------------------------------------------*/

614: /*M
615:     size - integer variable used to contain the number of processors in
616:            the relevent MPI_Comm

618:    Level: beginner

620: .seealso: rank, comm
621: M*/

623: /*M
624:     rank - integer variable used to contain the number of this processor relative
625:            to all in the relevent MPI_Comm

627:    Level: beginner

629: .seealso: size, comm
630: M*/

632: /*M
633:     comm - MPI_Comm used in the current routine or object

635:    Level: beginner

637: .seealso: size, rank
638: M*/

640: /*M
641:     PetscScalar - PETSc type that represents either a double precision real number or 
642:        a double precision complex number if the code is compiled with BOPT=g_complex or O_complex

644:    Level: beginner

646: M*/

648: /*
649:      The IBM include files define hz, here we hide it so that it may be used
650:    as a regular user variable.
651: */
652: #if defined(hz)
653: #undef hz
654: #endif

656: #endif