Actual source code: petsc.h
1: /*
2: This is the main PETSc include file (for C and C++). It is included by all
3: other PETSc include files, so it almost never has to be specifically included.
4: */
7: /* ========================================================================== */
8: /*
9: This facilitates using C version of PETSc from C++
10: */
15: #else
18: #endif
19: /* ========================================================================== */
20: /*
21: Current PETSc version number and release date
22: */
23: #include petscversion.h
25: /* ========================================================================== */
26: /*
27: petscconf.h is contained in bmake/${PETSC_ARCH}/petscconf.h it is
28: found automatically by the compiler due to the -I${PETSC_DIR}/bmake/${PETSC_ARCH}
29: in the bmake/common_variables definition of PETSC_INCLUDE
30: */
31: #include "petscconf.h"
33: /*
34: Currently cannot check formatting for PETSc print statements because we have our
35: own format %D
36: */
37: #undef PETSC_PRINTF_FORMAT_CHECK
38: #define PETSC_PRINTF_FORMAT_CHECK(a,b)
39: #undef PETSC_FPRINTF_FORMAT_CHECK
40: #define PETSC_FPRINTF_FORMAT_CHECK(a,b)
42: /*
43: Fixes for configure time choices which impact our interface. Currently only
44: calling conventions and extra compiler checking falls under this category.
45: */
46: #if !defined (PETSC_STDCALL)
47: #define PETSC_STDCALL
48: #endif
49: #if !defined (PETSC_TEMPLATE)
50: #define PETSC_TEMPLATE
51: #endif
53: /* ========================================================================== */
55: /*
56: Defines the interface to MPI allowing the use of all MPI functions.
57: */
58: #include "mpi.h"
59: /*
60: Yuck, we need to put stdio.h AFTER mpi.h for MPICH2 with C++ compiler
61: see the top of mpicxx.h
63: The MPI STANDARD HAS TO BE CHANGED to prevent this nonsense.
64: */
65: #include <stdio.h>
67: /*
68: All PETSc C functions return this error code, it is the final argument of
69: all Fortran subroutines
70: */
71: typedef int PetscErrorCode;
72: typedef int PetscCookie;
73: typedef int PetscEvent;
74: typedef int PetscBLASInt;
75: typedef int PetscMPIInt;
77: #if defined(PETSC_USE_64BIT_INT)
78: typedef long long PetscInt;
79: #define MPIU_INT MPI_LONG_LONG_INT
80: #else
81: typedef int PetscInt;
82: #define MPIU_INT MPI_INT
83: #endif
85: /*
87: */
91: /*
92: EXTERN indicates a PETSc function defined elsewhere
93: */
94: #if !defined(EXTERN)
95: #define EXTERN extern
96: #endif
98: /*
99: Defines some elementary mathematics functions and constants.
100: */
101: #include petscmath.h
103: /*
104: Basic PETSc constants
105: */
107: /*E
108: PetscTruth - Logical variable. Actually an integer
110: Level: beginner
112: E*/
113: typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth;
115: /*M
116: PETSC_FALSE - False value of PetscTruth
118: Level: beginner
120: Note: Zero integer
122: .seealso: PetscTruth
123: M*/
125: /*M
126: PETSC_TRUE - True value of PetscTruth
128: Level: beginner
130: Note: Nonzero integer
132: .seealso: PetscTruth
133: M*/
135: /*M
136: PETSC_YES - Alias for PETSC_TRUE
138: Level: beginner
140: Note: Zero integer
142: .seealso: PetscTruth
143: M*/
145: /*M
146: PETSC_NO - Alias for PETSC_FALSE
148: Level: beginner
150: Note: Nonzero integer
152: .seealso: PetscTruth
153: M*/
155: /*M
156: PETSC_NULL - standard way of passing in a null or array or pointer
158: Level: beginner
160: Notes: accepted by many PETSc functions to not set a parameter and instead use
161: some default
163: This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER,
164: PETSC_NULL_DOUBLE_PRECISION etc
166: .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE
168: M*/
169: #define PETSC_NULL 0
171: /*M
172: PETSC_DECIDE - standard way of passing in integer or floating point parameter
173: where you wish PETSc to use the default.
175: Level: beginner
177: .seealso: PETSC_NULL, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE
179: M*/
180: #define PETSC_DECIDE -1
182: /*M
183: PETSC_DEFAULT - standard way of passing in integer or floating point parameter
184: where you wish PETSc to use the default.
186: Level: beginner
188: .seealso: PETSC_DECIDE, PETSC_NULL, PETSC_IGNORE, PETSC_DETERMINE
190: M*/
191: #define PETSC_DEFAULT -2
193: #define PETSC_YES PETSC_TRUE
194: #define PETSC_NO PETSC_FALSE
196: /*M
197: PETSC_IGNORE - same as PETSC_NULL, means PETSc will ignore this argument
199: Level: beginner
201: Notes: accepted by many PETSc functions to not set a parameter and instead use
202: some default
204: This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER,
205: PETSC_NULL_DOUBLE_PRECISION etc
207: .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_NULL, PETSC_DETERMINE
209: M*/
210: #define PETSC_IGNORE PETSC_NULL
212: /*M
213: PETSC_DETERMINE - standard way of passing in integer or floating point parameter
214: where you wish PETSc to compute the required value.
216: Level: beginner
218: .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_NULL, VecSetSizes()
220: M*/
221: #define PETSC_DETERMINE PETSC_DECIDE
223: /*M
224: PETSC_COMM_WORLD - a duplicate of the MPI_COMM_WORLD communicator which represents
225: all the processs
227: Level: beginner
229: Notes: PETSC_COMM_WORLD and MPI_COMM_WORLD are equivalent except that passing MPI_COMM_WORLD
230: into PETSc object constructors will result in using more MPI resources since an MPI_Comm_dup()
231: will be done on it internally. We recommend always using PETSC_COMM_WORLD
233: .seealso: PETSC_COMM_SELF
235: M*/
238: /*M
239: PETSC_COMM_SELF - a duplicate of the MPI_COMM_SELF communicator which represents
240: the current process
242: Level: beginner
244: Notes: PETSC_COMM_SELF and MPI_COMM_SELF are equivalent except that passint MPI_COMM_SELF
245: into PETSc object constructors will result in using more MPI resources since an MPI_Comm_dup()
246: will be done on it internally. We recommend always using PETSC_COMM_SELF
248: .seealso: PETSC_COMM_WORLD
250: M*/
254: EXTERN PetscErrorCode PetscSetCommWorld(MPI_Comm);
255: EXTERN PetscErrorCode PetscSetHelpVersionFunctions(PetscErrorCode (*)(MPI_Comm),PetscErrorCode (*)(MPI_Comm));
256: EXTERN PetscErrorCode PetscCommDuplicate(MPI_Comm,MPI_Comm*,int*);
257: EXTERN PetscErrorCode PetscCommDestroy(MPI_Comm*);
259: /*MC
260: PetscMalloc - Allocates memory
262: Input Parameter:
263: . m - number of bytes to allocate
265: Output Parameter:
266: . result - memory allocated
268: Synopsis:
269: PetscErrorCode PetscMalloc(size_t m,void **result)
271: Level: beginner
273: Notes: Memory is always allocated at least double aligned
275: If you request memory of zero size it will allocate no space and assign the pointer to 0; PetscFree() will
276: properly handle not freeing the null pointer.
278: .seealso: PetscFree(), PetscNew()
280: Concepts: memory allocation
282: M*/
283: #define PetscMalloc(a,b) ((a != 0) ? (*PetscTrMalloc)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__,(void**)(b)) : (*(b) = 0,0) )
285: /*MC
286: PetscMalloc2 - Allocates 2 chunks of memory
288: Input Parameter:
289: + m1 - number of elements to allocate in 1st chunk (may be zero)
290: . t1 - type of first memory elements
291: . m2 - number of elements to allocate in 2nd chunk (may be zero)
292: - t2 - type of second memory elements
294: Output Parameter:
295: + r1 - memory allocated in first chunk
296: - r2 - memory allocated in second chunk
298: Synopsis:
299: PetscErrorCode PetscMalloc2(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2)
301: Level: developer
303: Notes: Memory of first chunk is always allocated at least double aligned
305: .seealso: PetscFree(), PetscNew(), PetscMalloc()
307: Concepts: memory allocation
309: M*/
310: #if defined(PETSC_USE_BOPT_g)
311: #define PetscMalloc2(m1,t1,r1,m2,t2,r2) (PetscMalloc((m1)*sizeof(t1),r1) || PetscMalloc((m2)*sizeof(t2),r2))
312: #else
313: #define PetscMalloc2(m1,t1,r1,m2,t2,r2) (PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2),r1) || (*(r2) = (t2*)(*(r1)+m1),0))
314: #endif
316: /*MC
317: PetscMalloc3 - Allocates 3 chunks of memory
319: Input Parameter:
320: + m1 - number of elements to allocate in 1st chunk (may be zero)
321: . t1 - type of first memory elements
322: . m2 - number of elements to allocate in 2nd chunk (may be zero)
323: . t2 - type of second memory elements
324: . m3 - number of elements to allocate in 3rd chunk (may be zero)
325: - t3 - type of third memory elements
327: Output Parameter:
328: + r1 - memory allocated in first chunk
329: . r2 - memory allocated in second chunk
330: - r3 - memory allocated in third chunk
332: Synopsis:
333: PetscErrorCode PetscMalloc3(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2,size_t m3,type t3,void **r3)
335: Level: developer
337: Notes: Memory of first chunk is always allocated at least double aligned
339: .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3()
341: Concepts: memory allocation
343: M*/
344: #if defined(PETSC_USE_BOPT_g)
345: #define PetscMalloc3(m1,t1,r1,m2,t2,r2,m3,t3,r3) (PetscMalloc((m1)*sizeof(t1),r1) || PetscMalloc((m2)*sizeof(t2),r2) || PetscMalloc((m3)*sizeof(t3),r3))
346: #else
347: #define PetscMalloc3(m1,t1,r1,m2,t2,r2,m3,t3,r3) (PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3),r1) || (*(r2) = (t2*)(*(r1)+m1),*(r3) = (t3*)(*(r2)+m2),0))
348: #endif
350: /*MC
351: PetscMalloc4 - Allocates 4 chunks of memory
353: Input Parameter:
354: + m1 - number of elements to allocate in 1st chunk (may be zero)
355: . t1 - type of first memory elements
356: . m2 - number of elements to allocate in 2nd chunk (may be zero)
357: . t2 - type of second memory elements
358: . m3 - number of elements to allocate in 3rd chunk (may be zero)
359: . t3 - type of third memory elements
360: . m4 - number of elements to allocate in 4th chunk (may be zero)
361: - t4 - type of fourth memory elements
363: Output Parameter:
364: + r1 - memory allocated in first chunk
365: . r2 - memory allocated in second chunk
366: . r3 - memory allocated in third chunk
367: - r4 - memory allocated in fourth chunk
369: Synopsis:
370: PetscErrorCode PetscMalloc4(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2,size_t m3,type t3,void **r3,size_t m4,type t4,void **r4)
372: Level: developer
374: Notes: Memory of first chunk is always allocated at least double aligned
376: .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4()
378: Concepts: memory allocation
380: M*/
381: #if defined(PETSC_USE_BOPT_g)
382: #define PetscMalloc4(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4) (PetscMalloc((m1)*sizeof(t1),r1) || PetscMalloc((m2)*sizeof(t2),r2) || PetscMalloc((m3)*sizeof(t3),r3) || PetscMalloc((m4)*sizeof(t4),r4))
383: #else
384: #define PetscMalloc4(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4) (PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3)+(m4)*sizeof(t4),r1) || (*(r2) = (t2*)(*(r1)+m1),*(r3) = (t3*)(*(r2)+m2),*(r4) = (t4*)(*(r3)+m3),0))
385: #endif
387: /*MC
388: PetscMalloc5 - Allocates 5 chunks of memory
390: Input Parameter:
391: + m1 - number of elements to allocate in 1st chunk (may be zero)
392: . t1 - type of first memory elements
393: . m2 - number of elements to allocate in 2nd chunk (may be zero)
394: . t2 - type of second memory elements
395: . m3 - number of elements to allocate in 3rd chunk (may be zero)
396: . t3 - type of third memory elements
397: . m4 - number of elements to allocate in 4th chunk (may be zero)
398: . t4 - type of fourth memory elements
399: . m5 - number of elements to allocate in 5th chunk (may be zero)
400: - t5 - type of fifth memory elements
402: Output Parameter:
403: + r1 - memory allocated in first chunk
404: . r2 - memory allocated in second chunk
405: . r3 - memory allocated in third chunk
406: . r4 - memory allocated in fourth chunk
407: - r5 - memory allocated in fifth chunk
409: Synopsis:
410: PetscErrorCode PetscMalloc5(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2,size_t m3,type t3,void **r3,size_t m4,type t4,void **r4,size_t m5,type t5,void **r5)
412: Level: developer
414: Notes: Memory of first chunk is always allocated at least double aligned
416: .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5()
418: Concepts: memory allocation
420: M*/
421: #if defined(PETSC_USE_BOPT_g)
422: #define PetscMalloc5(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5) (PetscMalloc((m1)*sizeof(t1),r1) || PetscMalloc((m2)*sizeof(t2),r2) || PetscMalloc((m3)*sizeof(t3),r3) || PetscMalloc((m4)*sizeof(t4),r4) || PetscMalloc((m5)*sizeof(t5),r5))
423: #else
424: #define PetscMalloc5(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5) (PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3)+(m4)*sizeof(t4)+(m5)*sizeof(t5),r1) || (*(r2) = (t2*)(*(r1)+m1),*(r3) = (t3*)(*(r2)+m2),*(r4) = (t4*)(*(r3)+m3),*(r5) = (t5*)(*(r4)+m4),0))
425: #endif
428: /*MC
429: PetscMalloc6 - Allocates 6 chunks of memory
431: Input Parameter:
432: + m1 - number of elements to allocate in 1st chunk (may be zero)
433: . t1 - type of first memory elements
434: . m2 - number of elements to allocate in 2nd chunk (may be zero)
435: . t2 - type of second memory elements
436: . m3 - number of elements to allocate in 3rd chunk (may be zero)
437: . t3 - type of third memory elements
438: . m4 - number of elements to allocate in 4th chunk (may be zero)
439: . t4 - type of fourth memory elements
440: . m5 - number of elements to allocate in 5th chunk (may be zero)
441: . t5 - type of fifth memory elements
442: . m6 - number of elements to allocate in 6th chunk (may be zero)
443: - t6 - type of sixth memory elements
445: Output Parameter:
446: + r1 - memory allocated in first chunk
447: . r2 - memory allocated in second chunk
448: . r3 - memory allocated in third chunk
449: . r4 - memory allocated in fourth chunk
450: . r5 - memory allocated in fifth chunk
451: - r6 - memory allocated in sixth chunk
453: Synopsis:
454: PetscErrorCode PetscMalloc6(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2,size_t m3,type t3,void **r3,size_t m4,type t4,void **r4,size_t m5,type t5,void **r5,size_t m6,type t6,void **r6)
456: Level: developer
458: Notes: Memory of first chunk is always allocated at least double aligned
460: .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5(), PetscFree6()
462: Concepts: memory allocation
464: M*/
465: #if defined(PETSC_USE_BOPT_g)
466: #define PetscMalloc6(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5,m6,t6,r6) (PetscMalloc((m1)*sizeof(t1),r1) || PetscMalloc((m2)*sizeof(t2),r2) || PetscMalloc((m3)*sizeof(t3),r3) || PetscMalloc((m4)*sizeof(t4),r4) || PetscMalloc((m5)*sizeof(t5),r5) || PetscMalloc((m6)*sizeof(t6),r6))
467: #else
468: #define PetscMalloc6(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5,m6,t6,r6) (PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3)+(m4)*sizeof(t4)+(m5)*sizeof(t5)+(m6)*sizeof(t6),r1) || (*(r2) = (t2*)(*(r1)+m1),*(r3) = (t3*)(*(r2)+m2),*(r4) = (t4*)(*(r3)+m3),*(r5) = (t5*)(*(r4)+m4),*(r6) = (t6*)(*(r5)+m5),0))
469: #endif
471: /*MC
472: PetscNew - Allocates memory of a particular type
474: Input Parameter:
475: . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated
477: Output Parameter:
478: . result - memory allocated
480: Synopsis:
481: PetscErrorCode PetscNew(struct type,((type *))result)
483: Level: beginner
485: .seealso: PetscFree(), PetscMalloc()
487: Concepts: memory allocation
489: M*/
490: #define PetscNew(A,b) PetscMalloc(sizeof(A),(b))
492: /*MC
493: PetscFree - Frees memory
495: Input Parameter:
496: . memory - memory to free
498: Synopsis:
499: PetscErrorCode PetscFree(void *memory)
501: Level: beginner
503: Notes: Memory must have been obtained with PetscNew() or PetscMalloc()
505: .seealso: PetscNew(), PetscMalloc()
507: Concepts: memory allocation
509: M*/
510: #define PetscFree(a) ((a) ? ((*PetscTrFree)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__) || ((a = 0),0)) : 0)
512: /*MC
513: PetscFree2 - Frees 2 chunks of memory obtained with PetscMalloc2()
515: Input Parameter:
516: + memory1 - memory to free
517: - memory2 - 2nd memory to free
520: Synopsis:
521: PetscErrorCode PetscFree2(void *memory1,void *memory2)
523: Level: developer
525: Notes: Memory must have been obtained with PetscMalloc2()
527: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree()
529: Concepts: memory allocation
531: M*/
532: #if defined(PETSC_USE_BOPT_g)
533: #define PetscFree2(m1,m2) (PetscFree(m2) || PetscFree(m1))
534: #else
535: #define PetscFree2(m1,m2) (PetscFree(m1))
536: #endif
538: /*MC
539: PetscFree3 - Frees 3 chunks of memory obtained with PetscMalloc3()
541: Input Parameter:
542: + memory1 - memory to free
543: . memory2 - 2nd memory to free
544: - memory3 - 3rd memory to free
547: Synopsis:
548: PetscErrorCode PetscFree3(void *memory1,void *memory2,void *memory3)
550: Level: developer
552: Notes: Memory must have been obtained with PetscMalloc3()
554: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3()
556: Concepts: memory allocation
558: M*/
559: #if defined(PETSC_USE_BOPT_g)
560: #define PetscFree3(m1,m2,m3) (PetscFree(m3) || PetscFree(m2) || PetscFree(m1))
561: #else
562: #define PetscFree3(m1,m2,m3) (PetscFree(m1))
563: #endif
565: /*MC
566: PetscFree4 - Frees 4 chunks of memory obtained with PetscMalloc4()
568: Input Parameter:
569: + m1 - memory to free
570: . m2 - 2nd memory to free
571: . m3 - 3rd memory to free
572: - m4 - 4th memory to free
575: Synopsis:
576: PetscErrorCode PetscFree4(void *m1,void *m2,void *m3,void *m4)
578: Level: developer
580: Notes: Memory must have been obtained with PetscMalloc4()
582: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4()
584: Concepts: memory allocation
586: M*/
587: #if defined(PETSC_USE_BOPT_g)
588: #define PetscFree4(m1,m2,m3,m4) (PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1))
589: #else
590: #define PetscFree4(m1,m2,m3,m4) (PetscFree(m1))
591: #endif
593: /*MC
594: PetscFree5 - Frees 5 chunks of memory obtained with PetscMalloc5()
596: Input Parameter:
597: + m1 - memory to free
598: . m2 - 2nd memory to free
599: . m3 - 3rd memory to free
600: . m4 - 4th memory to free
601: - m5 - 5th memory to free
604: Synopsis:
605: PetscErrorCode PetscFree5(void *m1,void *m2,void *m3,void *m4,void *m5)
607: Level: developer
609: Notes: Memory must have been obtained with PetscMalloc5()
611: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5()
613: Concepts: memory allocation
615: M*/
616: #if defined(PETSC_USE_BOPT_g)
617: #define PetscFree5(m1,m2,m3,m4,m5) (PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1))
618: #else
619: #define PetscFree5(m1,m2,m3,m4,m5) (PetscFree(m1))
620: #endif
623: /*MC
624: PetscFree6 - Frees 6 chunks of memory obtained with PetscMalloc6()
626: Input Parameter:
627: + m1 - memory to free
628: . m2 - 2nd memory to free
629: . m3 - 3rd memory to free
630: . m4 - 4th memory to free
631: . m5 - 5th memory to free
632: - m6 - 6th memory to free
635: Synopsis:
636: PetscErrorCode PetscFree6(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6)
638: Level: developer
640: Notes: Memory must have been obtained with PetscMalloc6()
642: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5(), PetscMalloc6()
644: Concepts: memory allocation
646: M*/
647: #if defined(PETSC_USE_BOPT_g)
648: #define PetscFree6(m1,m2,m3,m4,m5,m6) (PetscFree(m6) || PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1))
649: #else
650: #define PetscFree6(m1,m2,m3,m4,m5,m6) (PetscFree(m1))
651: #endif
653: EXTERN PetscErrorCode (*PetscTrMalloc)(size_t,int,const char[],const char[],const char[],void**);
654: EXTERN PetscErrorCode (*PetscTrFree)(void*,int,const char[],const char[],const char[]);
655: EXTERN PetscErrorCode PetscSetMalloc(PetscErrorCode (*)(size_t,int,const char[],const char[],const char[],void**),PetscErrorCode (*)(void*,int,const char[],const char[],const char[]));
656: EXTERN PetscErrorCode PetscClearMalloc(void);
658: /*
659: Routines for tracing memory corruption/bleeding with default PETSc
660: memory allocation
661: */
662: EXTERN PetscErrorCode PetscTrDump(FILE *);
663: EXTERN PetscErrorCode PetscTrSpace(PetscLogDouble *,PetscLogDouble *,PetscLogDouble *);
664: EXTERN PetscErrorCode PetscTrValid(int,const char[],const char[],const char[]);
665: EXTERN PetscErrorCode PetscTrDebug(PetscTruth);
666: EXTERN PetscErrorCode PetscTrLog(void);
667: EXTERN PetscErrorCode PetscTrLogDump(FILE *);
668: EXTERN PetscErrorCode PetscGetResidentSetSize(PetscLogDouble *);
670: /*
671: Variable type where we stash PETSc object pointers in Fortran.
672: Assumes that sizeof(long) == sizeof(void*)which is true on
673: all machines that we know.
674: */
675: #define PetscFortranAddr long
677: /*E
678: PetscDataType - Used for handling different basic data types.
680: Level: beginner
682: .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(),
683: PetscDataTypeGetSize(), PetscDataTypeGetName()
685: E*/
686: typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2,
687: PETSC_LONG = 3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5,
688: PETSC_CHAR = 6,PETSC_LOGICAL = 7} PetscDataType;
689: #if defined(PETSC_USE_COMPLEX)
690: #define PETSC_SCALAR PETSC_COMPLEX
691: #else
692: #if defined(PETSC_USE_SINGLE)
693: #define PETSC_SCALAR PETSC_FLOAT
694: #else
695: #define PETSC_SCALAR PETSC_DOUBLE
696: #endif
697: #endif
698: #if defined(PETSC_USE_SINGLE)
699: #define PETSC_REAL PETSC_FLOAT
700: #else
701: #define PETSC_REAL PETSC_DOUBLE
702: #endif
703: #define PETSC_FORTRANADDR PETSC_LONG
705: EXTERN PetscErrorCode PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*);
706: EXTERN PetscErrorCode PetscDataTypeGetSize(PetscDataType,PetscInt*);
707: EXTERN PetscErrorCode PetscDataTypeGetName(PetscDataType,const char*[]);
709: /*
710: Basic memory and string operations. These are usually simple wrappers
711: around the basic Unix system calls, but a few of them have additional
712: functionality and/or error checking.
713: */
714: EXTERN PetscErrorCode PetscMemcpy(void*,const void *,size_t);
715: EXTERN PetscErrorCode PetscBitMemcpy(void*,PetscInt,const void*,PetscInt,PetscInt,PetscDataType);
716: EXTERN PetscErrorCode PetscMemmove(void*,void *,size_t);
717: EXTERN PetscErrorCode PetscMemzero(void*,size_t);
718: EXTERN PetscErrorCode PetscMemcmp(const void*,const void*,size_t,PetscTruth *);
719: EXTERN PetscErrorCode PetscStrlen(const char[],size_t*);
720: EXTERN PetscErrorCode PetscStrcmp(const char[],const char[],PetscTruth *);
721: EXTERN PetscErrorCode PetscStrgrt(const char[],const char[],PetscTruth *);
722: EXTERN PetscErrorCode PetscStrcasecmp(const char[],const char[],PetscTruth*);
723: EXTERN PetscErrorCode PetscStrncmp(const char[],const char[],size_t,PetscTruth*);
724: EXTERN PetscErrorCode PetscStrcpy(char[],const char[]);
725: EXTERN PetscErrorCode PetscStrcat(char[],const char[]);
726: EXTERN PetscErrorCode PetscStrncat(char[],const char[],size_t);
727: EXTERN PetscErrorCode PetscStrncpy(char[],const char[],size_t);
728: EXTERN PetscErrorCode PetscStrchr(const char[],char,char *[]);
729: EXTERN PetscErrorCode PetscStrtolower(char[]);
730: EXTERN PetscErrorCode PetscStrrchr(const char[],char,char *[]);
731: EXTERN PetscErrorCode PetscStrstr(const char[],const char[],char *[]);
732: EXTERN PetscErrorCode PetscStrallocpy(const char[],char *[]);
733: EXTERN PetscErrorCode PetscStrreplace(MPI_Comm,const char[],char[],size_t);
734: #define PetscStrfree(a) ((a) ? PetscFree(a) : 0)
735: /*S
736: PetscToken - 'Token' used for managing tokenizing strings
738: Level: intermediate
740: .seealso: PetscTokenCreate(), PetscTokenFind(), PetscTokenDestroy()
741: S*/
742: typedef struct {char token;char *array;char *current;} PetscToken;
744: EXTERN PetscErrorCode PetscTokenCreate(const char[],const char,PetscToken**);
745: EXTERN PetscErrorCode PetscTokenFind(PetscToken*,char *[]);
746: EXTERN PetscErrorCode PetscTokenDestroy(PetscToken*);
748: /*
749: These are MPI operations for MPI_Allreduce() etc
750: */
751: EXTERN MPI_Op PetscMaxSum_Op;
752: #if defined(PETSC_USE_COMPLEX)
753: EXTERN MPI_Op PetscSum_Op;
754: #else
755: #define PetscSum_Op MPI_SUM
756: #endif
757: EXTERN PetscErrorCode PetscMaxSum(MPI_Comm,const PetscInt[],PetscInt*,PetscInt*);
759: /*S
760: PetscObject - any PETSc object, PetscViewer, Mat, Vec, KSP etc
762: Level: beginner
764: Note: This is the base class from which all objects appear.
766: .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName()
767: S*/
768: typedef struct _p_PetscObject* PetscObject;
770: /*S
771: PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed
772: by string name
774: Level: advanced
776: .seealso: PetscFListAdd(), PetscFListDestroy()
777: S*/
778: typedef struct _PetscFList *PetscFList;
780: #include petscviewer.h
781: #include petscoptions.h
783: EXTERN PetscErrorCode PetscLogInfoAllow(PetscTruth,const char []);
784: EXTERN PetscErrorCode PetscShowMemoryUsage(PetscViewer,const char[]);
785: EXTERN PetscErrorCode PetscGetTime(PetscLogDouble*);
786: EXTERN PetscErrorCode PetscGetCPUTime(PetscLogDouble*);
787: EXTERN PetscErrorCode PetscSleep(int);
789: /*
790: Initialization of PETSc
791: */
792: EXTERN PetscErrorCode PetscInitialize(int*,char***,const char[],const char[]);
793: EXTERN PetscErrorCode PetscInitializeNoArguments(void);
794: EXTERN PetscErrorCode PetscInitialized(PetscTruth *);
795: EXTERN PetscErrorCode PetscFinalize(void);
796: EXTERN PetscErrorCode PetscInitializeFortran(void);
797: EXTERN PetscErrorCode PetscGetArgs(int*,char ***);
798: EXTERN PetscErrorCode PetscEnd(void);
800: typedef void (**PetscVoidFunction)(void);
802: /*
803: PetscTryMethod - Queries an object for a method, if it exists then calls it.
804: These are intended to be used only inside PETSc functions.
805: */
806: #define PetscTryMethod(obj,A,B,C) \
807: 0;{ PetscErrorCode (*f)B, __ierr; \
808: __PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);CHKERRQ(__ierr); \
809: if (f) {__(*f)C;CHKERRQ(__ierr);}\
810: }
811: #define PetscUseMethod(obj,A,B,C) \
812: 0;{ PetscErrorCode (*f)B, __ierr; \
813: __PetscObjectQueryFunction((PetscObject)obj,A,(PetscVoidFunction)&f);CHKERRQ(__ierr); \
814: if (f) {__(*f)C;CHKERRQ(__ierr);}\
815: else {SETERRQ1(PETSC_ERR_SUP,"Cannot locate function %s in object",A);} \
816: }
817: /*
818: Functions that can act on any PETSc object.
819: */
820: EXTERN PetscErrorCode PetscObjectDestroy(PetscObject);
821: EXTERN PetscErrorCode PetscObjectExists(PetscObject,PetscTruth*);
822: EXTERN PetscErrorCode PetscObjectGetComm(PetscObject,MPI_Comm *);
823: EXTERN PetscErrorCode PetscObjectGetCookie(PetscObject,int *);
824: EXTERN PetscErrorCode PetscObjectGetType(PetscObject,int *);
825: EXTERN PetscErrorCode PetscObjectSetName(PetscObject,const char[]);
826: EXTERN PetscErrorCode PetscObjectGetName(PetscObject,char*[]);
827: EXTERN PetscErrorCode PetscObjectReference(PetscObject);
828: EXTERN PetscErrorCode PetscObjectGetReference(PetscObject,PetscInt*);
829: EXTERN PetscErrorCode PetscObjectDereference(PetscObject);
830: EXTERN PetscErrorCode PetscObjectGetNewTag(PetscObject,PetscMPIInt *);
831: EXTERN PetscErrorCode PetscCommGetNewTag(MPI_Comm,PetscMPIInt *);
832: EXTERN PetscErrorCode PetscObjectView(PetscObject,PetscViewer);
833: EXTERN PetscErrorCode PetscObjectCompose(PetscObject,const char[],PetscObject);
834: EXTERN PetscErrorCode PetscObjectQuery(PetscObject,const char[],PetscObject *);
835: EXTERN PetscErrorCode PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)(void));
839: /*MC
840: PetscObjectComposeFunctionDynamic - Associates a function with a given PETSc object.
841:
842: Collective on PetscObject
844: Input Parameters:
845: + obj - the PETSc object; this must be cast with a (PetscObject), for example,
846: PetscObjectCompose((PetscObject)mat,...);
847: . name - name associated with the child function
848: . fname - name of the function
849: - ptr - function pointer (or PETSC_NULL if using dynamic libraries)
851: Level: advanced
853: Synopsis:
854: PetscErrorCode PetscObjectComposeFunctionDynamic(PetscObject obj,const char name[],const char fname[],void *ptr)
856: Notes:
857: To remove a registered routine, pass in a PETSC_NULL rname and fnc().
859: PetscObjectComposeFunctionDynamic() can be used with any PETSc object (such as
860: Mat, Vec, KSP, SNES, etc.) or any user-provided object.
863: work in C++/complex with dynamic link libraries (PETSC_USE_DYNAMIC_LIBRARIES)
864: enabled.
866: Concepts: objects^composing functions
867: Concepts: composing functions
868: Concepts: functions^querying
869: Concepts: objects^querying
870: Concepts: querying objects
872: .seealso: PetscObjectQueryFunction()
873: M*/
874: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
875: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0)
876: #else
877: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(FCNVOID)(d))
878: #endif
880: EXTERN PetscErrorCode PetscObjectQueryFunction(PetscObject,const char[],void (**)(void));
881: EXTERN PetscErrorCode PetscObjectSetOptionsPrefix(PetscObject,const char[]);
882: EXTERN PetscErrorCode PetscObjectAppendOptionsPrefix(PetscObject,const char[]);
883: EXTERN PetscErrorCode PetscObjectPrependOptionsPrefix(PetscObject,const char[]);
884: EXTERN PetscErrorCode PetscObjectGetOptionsPrefix(PetscObject,char*[]);
885: EXTERN PetscErrorCode PetscObjectPublish(PetscObject);
886: EXTERN PetscErrorCode PetscObjectChangeTypeName(PetscObject,const char[]);
887: EXTERN PetscErrorCode PetscObjectRegisterDestroy(PetscObject);
888: EXTERN PetscErrorCode PetscObjectRegisterDestroyAll(void);
889: EXTERN PetscErrorCode PetscObjectName(PetscObject);
890: EXTERN PetscErrorCode PetscTypeCompare(PetscObject,const char[],PetscTruth*);
892: /*
893: Defines PETSc error handling.
894: */
895: #include petscerror.h
897: /*S
898: PetscOList - Linked list of PETSc objects, accessable by string name
900: Level: advanced
902: .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind()
903: S*/
904: typedef struct _PetscOList *PetscOList;
906: EXTERN PetscErrorCode PetscOListDestroy(PetscOList *);
907: EXTERN PetscErrorCode PetscOListFind(PetscOList,const char[],PetscObject*);
908: EXTERN PetscErrorCode PetscOListReverseFind(PetscOList,PetscObject,char**);
909: EXTERN PetscErrorCode PetscOListAdd(PetscOList *,const char[],PetscObject);
910: EXTERN PetscErrorCode PetscOListDuplicate(PetscOList,PetscOList *);
912: /*
913: Dynamic library lists. Lists of names of routines in dynamic
914: link libraries that will be loaded as needed.
915: */
916: EXTERN PetscErrorCode PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void));
917: EXTERN PetscErrorCode PetscFListDestroy(PetscFList*);
918: EXTERN PetscErrorCode PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)(void));
919: EXTERN PetscErrorCode PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],const char[],const char[],PetscFList);
920: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
921: #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0)
922: #else
923: #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c)
924: #endif
925: EXTERN PetscErrorCode PetscFListDuplicate(PetscFList,PetscFList *);
926: EXTERN PetscErrorCode PetscFListView(PetscFList,PetscViewer);
927: EXTERN PetscErrorCode PetscFListConcat(const char [],const char [],char []);
928: EXTERN PetscErrorCode PetscFListGet(PetscFList,char ***,int*);
930: /*S
931: PetscDLLibraryList - Linked list of dynamics libraries to search for functions
933: Level: advanced
935: PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries
937: .seealso: PetscDLLibraryOpen()
938: S*/
939: typedef struct _PetscDLLibraryList *PetscDLLibraryList;
941: EXTERN PetscErrorCode PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *);
942: EXTERN PetscErrorCode PetscDLLibraryOpen(MPI_Comm,const char[],void **);
943: EXTERN PetscErrorCode PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **);
944: EXTERN PetscErrorCode PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]);
945: EXTERN PetscErrorCode PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]);
946: EXTERN PetscErrorCode PetscDLLibraryClose(PetscDLLibraryList);
947: EXTERN PetscErrorCode PetscDLLibraryPrintPath(void);
948: EXTERN PetscErrorCode PetscDLLibraryGetInfo(void*,const char[],const char *[]);
950: /*
951: Mechanism for translating PETSc object representations between languages
952: Not currently used.
953: */
954: typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage;
955: #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C
956: EXTERN PetscErrorCode PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *);
957: EXTERN PetscErrorCode PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **);
959: /*
960: Useful utility routines
961: */
962: EXTERN PetscErrorCode PetscSplitOwnership(MPI_Comm,PetscInt*,PetscInt*);
963: EXTERN PetscErrorCode PetscSplitOwnershipBlock(MPI_Comm,PetscInt,PetscInt*,PetscInt*);
964: EXTERN PetscErrorCode PetscSequentialPhaseBegin(MPI_Comm,PetscMPIInt);
965: EXTERN PetscErrorCode PetscSequentialPhaseEnd(MPI_Comm,PetscMPIInt);
966: EXTERN PetscErrorCode PetscBarrier(PetscObject);
967: EXTERN PetscErrorCode PetscMPIDump(FILE*);
969: #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE)
970: /*
971: Defines basic graphics available from PETSc.
972: */
973: #include petscdraw.h
975: /*
976: Defines the base data structures for all PETSc objects
977: */
978: #include petschead.h
980: /*
981: Defines PETSc profiling.
982: */
983: #include petsclog.h
985: /*
986: For locking, unlocking and destroying AMS memories associated with
987: PETSc objects. Not currently used.
988: */
989: #define PetscPublishAll(v) 0
990: #define PetscObjectTakeAccess(obj) 0
991: #define PetscObjectGrantAccess(obj) 0
992: #define PetscObjectDepublish(obj) 0
996: /*
997: This code allows one to pass a MPI communicator between
998: C and Fortran. MPI 2.0 defines a standard API for doing this.
999: The code here is provided to allow PETSc to work with MPI 1.1
1000: standard MPI libraries.
1001: */
1002: EXTERN PetscErrorCode MPICCommToFortranComm(MPI_Comm,int *);
1003: EXTERN PetscErrorCode MPIFortranCommToCComm(int,MPI_Comm*);
1005: /*
1006: Simple PETSc parallel IO for ASCII printing
1007: */
1008: EXTERN PetscErrorCode PetscFixFilename(const char[],char[]);
1009: EXTERN PetscErrorCode PetscFOpen(MPI_Comm,const char[],const char[],FILE**);
1010: EXTERN PetscErrorCode PetscFClose(MPI_Comm,FILE*);
1011: EXTERN PetscErrorCode PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4);
1012: EXTERN PetscErrorCode PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3);
1014: /* These are used internally by PETSc ASCII IO routines*/
1015: #include <stdarg.h>
1016: EXTERN PetscErrorCode PetscVSNPrintf(char*,size_t,const char*,va_list);
1017: EXTERN PetscErrorCode PetscVFPrintf(FILE*,const char*,va_list);
1019: /*MC
1020: PetscErrorPrintf - Prints error messages.
1022: Not Collective
1024: Synopsis:
1025: PetscErrorCode (*PetscErrorPrintf)(const char format[],...);
1027: Input Parameters:
1028: . format - the usual printf() format string
1030: Options Database Keys:
1031: . -error_output_stderr - cause error messages to be printed to stderr instead of the
1032: (default) stdout
1035: Level: developer
1037: Fortran Note:
1038: This routine is not supported in Fortran.
1040: Concepts: error messages^printing
1041: Concepts: printing^error messages
1043: .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscHelpPrintf()
1044: M*/
1045: EXTERN PetscErrorCode (*PetscErrorPrintf)(const char[],...);
1047: /*MC
1048: PetscHelpPrintf - Prints help messages.
1050: Not Collective
1052: Synopsis:
1053: PetscErrorCode (*PetscHelpPrintf)(const char format[],...);
1055: Input Parameters:
1056: . format - the usual printf() format string
1058: Level: developer
1060: Fortran Note:
1061: This routine is not supported in Fortran.
1063: Concepts: help messages^printing
1064: Concepts: printing^help messages
1066: .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscErrorPrintf()
1067: M*/
1068: EXTERN PetscErrorCode (*PetscHelpPrintf)(MPI_Comm,const char[],...);
1070: EXTERN PetscErrorCode PetscPOpen(MPI_Comm,const char[],const char[],const char[],FILE **);
1071: EXTERN PetscErrorCode PetscPClose(MPI_Comm,FILE*);
1072: EXTERN PetscErrorCode PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3);
1073: EXTERN PetscErrorCode PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4);
1074: EXTERN PetscErrorCode PetscSynchronizedFlush(MPI_Comm);
1075: EXTERN PetscErrorCode PetscSynchronizedFGets(MPI_Comm,FILE*,size_t,char[]);
1076: EXTERN PetscErrorCode PetscStartMatlab(MPI_Comm,const char[],const char[],FILE**);
1077: EXTERN PetscErrorCode PetscStartJava(MPI_Comm,const char[],const char[],FILE**);
1078: EXTERN PetscErrorCode PetscGetPetscDir(const char*[]);
1080: EXTERN PetscErrorCode PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*);
1081: /*S
1082: PetscObjectContainer - Simple PETSc object that contains a pointer to any required data
1084: Level: advanced
1086: .seealso: PetscObject, PetscObjectContainerCreate()
1087: S*/
1088: typedef struct _p_PetscObjectContainer* PetscObjectContainer;
1089: EXTERN PetscErrorCode PetscObjectContainerGetPointer(PetscObjectContainer,void **);
1090: EXTERN PetscErrorCode PetscObjectContainerSetPointer(PetscObjectContainer,void *);
1091: EXTERN PetscErrorCode PetscObjectContainerDestroy(PetscObjectContainer);
1092: EXTERN PetscErrorCode PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *);
1094: /*
1095: For incremental debugging
1096: */
1098: EXTERN PetscErrorCode PetscCompareDouble(double);
1099: EXTERN PetscErrorCode PetscCompareScalar(PetscScalar);
1100: EXTERN PetscErrorCode PetscCompareInt(PetscInt);
1102: /*
1103: For use in debuggers
1104: */
1106: EXTERN PetscErrorCode PetscIntView(PetscInt,PetscInt[],PetscViewer);
1107: EXTERN PetscErrorCode PetscRealView(PetscInt,PetscReal[],PetscViewer);
1108: EXTERN PetscErrorCode PetscScalarView(PetscInt,PetscScalar[],PetscViewer);
1110: /*
1111: Allows accessing Matlab Engine
1112: */
1113: #include petscmatlab.h
1115: /*
1116: C code optimization is often enhanced by telling the compiler
1117: that certain pointer arguments to functions are not aliased to
1118: to other arguments. This is not yet ANSI C standard so we define
1119: the macro "restrict" to indicate that the variable is not aliased
1120: to any other argument.
1121: */
1122: #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus)
1123: #define restrict _Restrict
1124: #else
1125: #if defined(restrict)
1126: #undef restrict
1127: #endif
1128: #define restrict
1129: #endif
1131: /*
1132: Determine if some of the kernel computation routines use
1133: Fortran (rather than C) for the numerical calculations. On some machines
1134: and compilers (like complex numbers) the Fortran version of the routines
1135: is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS
1136: would be set in the petscconf.h file
1137: */
1138: #if defined(PETSC_USE_FORTRAN_KERNELS)
1140: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ)
1141: #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ
1142: #endif
1144: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ)
1145: #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ
1146: #endif
1148: #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM)
1149: #define PETSC_USE_FORTRAN_KERNEL_NORM
1150: #endif
1152: #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY)
1153: #define PETSC_USE_FORTRAN_KERNEL_MAXPY
1154: #endif
1156: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ)
1157: #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ
1158: #endif
1160: #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ)
1161: #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ
1162: #endif
1164: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ)
1165: #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ
1166: #endif
1168: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ)
1169: #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ
1170: #endif
1172: #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT)
1173: #define PETSC_USE_FORTRAN_KERNEL_MDOT
1174: #endif
1176: #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY)
1177: #define PETSC_USE_FORTRAN_KERNEL_XTIMESY
1178: #endif
1180: #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX)
1181: #define PETSC_USE_FORTRAN_KERNEL_AYPX
1182: #endif
1184: #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY)
1185: #define PETSC_USE_FORTRAN_KERNEL_WAXPY
1186: #endif
1188: #endif
1190: /*
1191: Macros for indicating code that should be compiled with a C interface,
1192: rather than a C++ interface. Any routines that are dynamically loaded
1193: (such as the PCCreate_XXX() routines) must be wrapped so that the name
1194: mangler does not change the functions symbol name. This just hides the
1196: */
1197: #if defined(__cplusplus)
1200: #else
1203: #endif
1205: /* --------------------------------------------------------------------*/
1207: /*M
1208: size - integer variable used to contain the number of processors in
1209: the relevent MPI_Comm
1211: Level: beginner
1213: .seealso: rank, comm
1214: M*/
1216: /*M
1217: rank - integer variable used to contain the number of this processor relative
1218: to all in the relevent MPI_Comm
1220: Level: beginner
1222: .seealso: size, comm
1223: M*/
1225: /*M
1226: comm - MPI_Comm used in the current routine or object
1228: Level: beginner
1230: .seealso: size, rank
1231: M*/
1233: /*M
1234: MPI_Comm - the basic object used by MPI to determine which processes are involved in a
1235: communication
1237: Level: beginner
1239: Note: This manual page is a place-holder because MPICH does not have a manual page for MPI_Comm
1241: .seealso: size, rank, comm, PETSC_COMM_WORLD, PETSC_COMM_SELF
1242: M*/
1244: /*M
1245: PetscScalar - PETSc type that represents either a double precision real number or
1246: a double precision complex number if the code is compiled with BOPT=g_complex or O_complex
1248: Level: beginner
1250: .seealso: PetscReal, PassiveReal, PassiveScalar
1251: M*/
1253: /*M
1254: PetscReal - PETSc type that represents a double precision real number
1256: Level: beginner
1258: .seealso: PetscScalar, PassiveReal, PassiveScalar
1259: M*/
1261: /*M
1262: PassiveScalar - PETSc type that represents either a double precision real number or
1263: a double precision complex number if the code is compiled with BOPT=g_complex or O_complex
1265: Level: beginner
1267: This is the same as a PetscScalar except in code that is automatically differentiated it is
1268: treated as a constant (not an indendent or dependent variable)
1270: .seealso: PetscReal, PassiveReal, PetscScalar
1271: M*/
1273: /*M
1274: PassiveReal - PETSc type that represents a double precision real number
1276: Level: beginner
1278: This is the same as a PetscReal except in code that is automatically differentiated it is
1279: treated as a constant (not an indendent or dependent variable)
1281: .seealso: PetscScalar, PetscReal, PassiveScalar
1282: M*/
1284: /*M
1285: MPIU_SCALAR - MPI datatype corresponding to PetscScalar
1287: Level: beginner
1289: Note: In MPI calls that require an MPI datatype that matches a PetscScalar or array of PetscScalars
1290: pass this value
1292: .seealso: PetscReal, PassiveReal, PassiveScalar, PetscScalar
1293: M*/
1295: /*
1296: The IBM include files define hz, here we hide it so that it may be used
1297: as a regular user variable.
1298: */
1299: #if defined(hz)
1300: #undef hz
1301: #endif
1303: /* For arrays that contain filenames or paths */
1306: #if defined(PETSC_HAVE_LIMITS_H)
1307: #include <limits.h>
1308: #endif
1309: #if defined(PETSC_HAVE_SYS_PARAM_H)
1310: #include <sys/param.h>
1311: #endif
1312: #if defined(PETSC_HAVE_SYS_TYPES_H)
1313: #include <sys/types.h>
1314: #endif
1315: #if defined(MAXPATHLEN)
1316: # define PETSC_MAX_PATH_LEN MAXPATHLEN
1317: #elif defined(MAX_PATH)
1318: # define PETSC_MAX_PATH_LEN MAX_PATH
1319: #elif defined(_MAX_PATH)
1320: # define PETSC_MAX_PATH_LEN _MAX_PATH
1321: #else
1322: # define PETSC_MAX_PATH_LEN 4096
1323: #endif
1326: #endif