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