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: #include <stdio.h>
56: /*
57: Defines the interface to MPI allowing the use of all MPI functions.
58: */
59: #include "mpi.h"
61: /*
62: All PETSc C functions return this error code, it is the final argument of
63: all Fortran subroutines
64: */
65: typedef int PetscErrorCode;
66: typedef int PetscCookie;
67: typedef int PetscEvent;
68: typedef int PetscBLASInt;
69: typedef int PetscMPIInt;
71: #if defined(PETSC_USE_64BIT_INT)
72: typedef long long PetscInt;
73: #define MPIU_INT MPI_LONG_LONG_INT
74: #else
75: typedef int PetscInt;
76: #define MPIU_INT MPI_INT
77: #endif
79: /*
81: */
85: /*
86: EXTERN indicates a PETSc function defined elsewhere
87: */
88: #if !defined(EXTERN)
89: #define EXTERN extern
90: #endif
92: /*
93: Defines some elementary mathematics functions and constants.
94: */
95: #include petscmath.h
97: /*
98: Basic PETSc constants
99: */
101: /*E
102: PetscTruth - Logical variable. Actually an integer
104: Level: beginner
106: E*/
107: typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth;
109: /*M
110: PETSC_FALSE - False value of PetscTruth
112: Level: beginner
114: Note: Zero integer
116: .seealso: PetscTruth
117: M*/
119: /*M
120: PETSC_TRUE - True value of PetscTruth
122: Level: beginner
124: Note: Nonzero integer
126: .seealso: PetscTruth
127: M*/
129: /*M
130: PETSC_YES - Alias for PETSC_TRUE
132: Level: beginner
134: Note: Zero integer
136: .seealso: PetscTruth
137: M*/
139: /*M
140: PETSC_NO - Alias for PETSC_FALSE
142: Level: beginner
144: Note: Nonzero integer
146: .seealso: PetscTruth
147: M*/
149: /*M
150: PETSC_NULL - standard way of passing in a null or array or pointer
152: Level: beginner
154: Notes: accepted by many PETSc functions to not set a parameter and instead use
155: some default
157: This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER,
158: PETSC_NULL_DOUBLE_PRECISION etc
160: .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE
162: M*/
163: #define PETSC_NULL 0
165: /*M
166: PETSC_DECIDE - standard way of passing in integer or floating point parameter
167: where you wish PETSc to use the default.
169: Level: beginner
171: .seealso: PETSC_NULL, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE
173: M*/
174: #define PETSC_DECIDE -1
176: /*M
177: PETSC_DEFAULT - standard way of passing in integer or floating point parameter
178: where you wish PETSc to use the default.
180: Level: beginner
182: .seealso: PETSC_DECIDE, PETSC_NULL, PETSC_IGNORE, PETSC_DETERMINE
184: M*/
185: #define PETSC_DEFAULT -2
187: #define PETSC_YES PETSC_TRUE
188: #define PETSC_NO PETSC_FALSE
190: /*M
191: PETSC_IGNORE - same as PETSC_NULL, means PETSc will ignore this argument
193: Level: beginner
195: Notes: accepted by many PETSc functions to not set a parameter and instead use
196: some default
198: This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER,
199: PETSC_NULL_DOUBLE_PRECISION etc
201: .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_NULL, PETSC_DETERMINE
203: M*/
204: #define PETSC_IGNORE PETSC_NULL
206: /*M
207: PETSC_DETERMINE - standard way of passing in integer or floating point parameter
208: where you wish PETSc to compute the required value.
210: Level: beginner
212: .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_NULL, VecSetSizes()
214: M*/
215: #define PETSC_DETERMINE PETSC_DECIDE
217: /*M
218: PETSC_COMM_WORLD - a duplicate of the MPI_COMM_WORLD communicator which represents
219: all the processs
221: Level: beginner
223: Notes: PETSC_COMM_WORLD and MPI_COMM_WORLD are equivalent except that passing MPI_COMM_WORLD
224: into PETSc object constructors will result in using more MPI resources since an MPI_Comm_dup()
225: will be done on it internally. We recommend always using PETSC_COMM_WORLD
227: .seealso: PETSC_COMM_SELF
229: M*/
232: /*M
233: PETSC_COMM_SELF - a duplicate of the MPI_COMM_SELF communicator which represents
234: the current process
236: Level: beginner
238: Notes: PETSC_COMM_SELF and MPI_COMM_SELF are equivalent except that passint MPI_COMM_SELF
239: into PETSc object constructors will result in using more MPI resources since an MPI_Comm_dup()
240: will be done on it internally. We recommend always using PETSC_COMM_SELF
242: .seealso: PETSC_COMM_WORLD
244: M*/
248: EXTERN PetscErrorCode PetscSetCommWorld(MPI_Comm);
249: EXTERN PetscErrorCode PetscSetHelpVersionFunctions(PetscErrorCode (*)(MPI_Comm),PetscErrorCode (*)(MPI_Comm));
250: EXTERN PetscErrorCode PetscCommDuplicate(MPI_Comm,MPI_Comm*,int*);
251: EXTERN PetscErrorCode PetscCommDestroy(MPI_Comm*);
253: /*MC
254: PetscMalloc - Allocates memory
256: Input Parameter:
257: . m - number of bytes to allocate
259: Output Parameter:
260: . result - memory allocated
262: Synopsis:
263: PetscErrorCode PetscMalloc(size_t m,void **result)
265: Level: beginner
267: Notes: Memory is always allocated at least double aligned
269: If you request memory of zero size it will allocate no space and assign the pointer to 0; PetscFree() will
270: properly handle not freeing the null pointer.
272: .seealso: PetscFree(), PetscNew()
274: Concepts: memory allocation
276: M*/
277: #define PetscMalloc(a,b) ((a != 0) ? (*PetscTrMalloc)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__,(void**)(b)) : (*(b) = 0,0) )
279: /*MC
280: PetscMalloc2 - Allocates 2 chunks of memory
282: Input Parameter:
283: + m1 - number of elements to allocate in 1st chunk (may be zero)
284: . t1 - type of first memory elements
285: . m2 - number of elements to allocate in 2nd chunk (may be zero)
286: - t2 - type of second memory elements
288: Output Parameter:
289: + r1 - memory allocated in first chunk
290: - r2 - memory allocated in second chunk
292: Synopsis:
293: PetscErrorCode PetscMalloc2(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2)
295: Level: developer
297: Notes: Memory of first chunk is always allocated at least double aligned
299: .seealso: PetscFree(), PetscNew(), PetscMalloc()
301: Concepts: memory allocation
303: M*/
304: #if defined(PETSC_USE_BOPT_g)
305: #define PetscMalloc2(m1,t1,r1,m2,t2,r2) (PetscMalloc((m1)*sizeof(t1),r1) || PetscMalloc((m2)*sizeof(t2),r2))
306: #else
307: #define PetscMalloc2(m1,t1,r1,m2,t2,r2) (PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2),r1) || (*(r2) = (t2*)(*(r1)+m1),0))
308: #endif
310: /*MC
311: PetscMalloc3 - Allocates 3 chunks of memory
313: Input Parameter:
314: + m1 - number of elements to allocate in 1st chunk (may be zero)
315: . t1 - type of first memory elements
316: . m2 - number of elements to allocate in 2nd chunk (may be zero)
317: . t2 - type of second memory elements
318: . m3 - number of elements to allocate in 3rd chunk (may be zero)
319: - t3 - type of third memory elements
321: Output Parameter:
322: + r1 - memory allocated in first chunk
323: . r2 - memory allocated in second chunk
324: - r3 - memory allocated in third chunk
326: Synopsis:
327: PetscErrorCode PetscMalloc3(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2,size_t m3,type t3,void **r3)
329: Level: developer
331: Notes: Memory of first chunk is always allocated at least double aligned
333: .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3()
335: Concepts: memory allocation
337: M*/
338: #if defined(PETSC_USE_BOPT_g)
339: #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))
340: #else
341: #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))
342: #endif
344: /*MC
345: PetscMalloc4 - Allocates 4 chunks of memory
347: Input Parameter:
348: + m1 - number of elements to allocate in 1st chunk (may be zero)
349: . t1 - type of first memory elements
350: . m2 - number of elements to allocate in 2nd chunk (may be zero)
351: . t2 - type of second memory elements
352: . m3 - number of elements to allocate in 3rd chunk (may be zero)
353: . t3 - type of third memory elements
354: . m4 - number of elements to allocate in 4th chunk (may be zero)
355: - t4 - type of fourth memory elements
357: Output Parameter:
358: + r1 - memory allocated in first chunk
359: . r2 - memory allocated in second chunk
360: . r3 - memory allocated in third chunk
361: - r4 - memory allocated in fourth chunk
363: Synopsis:
364: 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)
366: Level: developer
368: Notes: Memory of first chunk is always allocated at least double aligned
370: .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4()
372: Concepts: memory allocation
374: M*/
375: #if defined(PETSC_USE_BOPT_g)
376: #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))
377: #else
378: #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))
379: #endif
381: /*MC
382: PetscMalloc5 - Allocates 5 chunks of memory
384: Input Parameter:
385: + m1 - number of elements to allocate in 1st chunk (may be zero)
386: . t1 - type of first memory elements
387: . m2 - number of elements to allocate in 2nd chunk (may be zero)
388: . t2 - type of second memory elements
389: . m3 - number of elements to allocate in 3rd chunk (may be zero)
390: . t3 - type of third memory elements
391: . m4 - number of elements to allocate in 4th chunk (may be zero)
392: . t4 - type of fourth memory elements
393: . m5 - number of elements to allocate in 5th chunk (may be zero)
394: - t5 - type of fifth memory elements
396: Output Parameter:
397: + r1 - memory allocated in first chunk
398: . r2 - memory allocated in second chunk
399: . r3 - memory allocated in third chunk
400: . r4 - memory allocated in fourth chunk
401: - r5 - memory allocated in fifth chunk
403: Synopsis:
404: 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)
406: Level: developer
408: Notes: Memory of first chunk is always allocated at least double aligned
410: .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5()
412: Concepts: memory allocation
414: M*/
415: #if defined(PETSC_USE_BOPT_g)
416: #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))
417: #else
418: #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))
419: #endif
422: /*MC
423: PetscMalloc6 - Allocates 6 chunks of memory
425: Input Parameter:
426: + m1 - number of elements to allocate in 1st chunk (may be zero)
427: . t1 - type of first memory elements
428: . m2 - number of elements to allocate in 2nd chunk (may be zero)
429: . t2 - type of second memory elements
430: . m3 - number of elements to allocate in 3rd chunk (may be zero)
431: . t3 - type of third memory elements
432: . m4 - number of elements to allocate in 4th chunk (may be zero)
433: . t4 - type of fourth memory elements
434: . m5 - number of elements to allocate in 5th chunk (may be zero)
435: . t5 - type of fifth memory elements
436: . m6 - number of elements to allocate in 6th chunk (may be zero)
437: - t6 - type of sixth memory elements
439: Output Parameter:
440: + r1 - memory allocated in first chunk
441: . r2 - memory allocated in second chunk
442: . r3 - memory allocated in third chunk
443: . r4 - memory allocated in fourth chunk
444: . r5 - memory allocated in fifth chunk
445: - r6 - memory allocated in sixth chunk
447: Synopsis:
448: 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)
450: Level: developer
452: Notes: Memory of first chunk is always allocated at least double aligned
454: .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5(), PetscFree6()
456: Concepts: memory allocation
458: M*/
459: #if defined(PETSC_USE_BOPT_g)
460: #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))
461: #else
462: #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))
463: #endif
465: /*MC
466: PetscNew - Allocates memory of a particular type
468: Input Parameter:
469: . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated
471: Output Parameter:
472: . result - memory allocated
474: Synopsis:
475: PetscErrorCode PetscNew(struct type,((type *))result)
477: Level: beginner
479: .seealso: PetscFree(), PetscMalloc()
481: Concepts: memory allocation
483: M*/
484: #define PetscNew(A,b) PetscMalloc(sizeof(A),(b))
486: /*MC
487: PetscFree - Frees memory
489: Input Parameter:
490: . memory - memory to free
492: Synopsis:
493: PetscErrorCode PetscFree(void *memory)
495: Level: beginner
497: Notes: Memory must have been obtained with PetscNew() or PetscMalloc()
499: .seealso: PetscNew(), PetscMalloc()
501: Concepts: memory allocation
503: M*/
504: #define PetscFree(a) ((a) ? ((*PetscTrFree)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__) || ((a = 0),0)) : 0)
506: /*MC
507: PetscFree2 - Frees 2 chunks of memory obtained with PetscMalloc2()
509: Input Parameter:
510: + memory1 - memory to free
511: - memory2 - 2nd memory to free
514: Synopsis:
515: PetscErrorCode PetscFree2(void *memory1,void *memory2)
517: Level: developer
519: Notes: Memory must have been obtained with PetscMalloc2()
521: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree()
523: Concepts: memory allocation
525: M*/
526: #if defined(PETSC_USE_BOPT_g)
527: #define PetscFree2(m1,m2) (PetscFree(m2) || PetscFree(m1))
528: #else
529: #define PetscFree2(m1,m2) (PetscFree(m1))
530: #endif
532: /*MC
533: PetscFree3 - Frees 3 chunks of memory obtained with PetscMalloc3()
535: Input Parameter:
536: + memory1 - memory to free
537: . memory2 - 2nd memory to free
538: - memory3 - 3rd memory to free
541: Synopsis:
542: PetscErrorCode PetscFree3(void *memory1,void *memory2,void *memory3)
544: Level: developer
546: Notes: Memory must have been obtained with PetscMalloc3()
548: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3()
550: Concepts: memory allocation
552: M*/
553: #if defined(PETSC_USE_BOPT_g)
554: #define PetscFree3(m1,m2,m3) (PetscFree(m3) || PetscFree(m2) || PetscFree(m1))
555: #else
556: #define PetscFree3(m1,m2,m3) (PetscFree(m1))
557: #endif
559: /*MC
560: PetscFree4 - Frees 4 chunks of memory obtained with PetscMalloc4()
562: Input Parameter:
563: + m1 - memory to free
564: . m2 - 2nd memory to free
565: . m3 - 3rd memory to free
566: - m4 - 4th memory to free
569: Synopsis:
570: PetscErrorCode PetscFree4(void *m1,void *m2,void *m3,void *m4)
572: Level: developer
574: Notes: Memory must have been obtained with PetscMalloc4()
576: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4()
578: Concepts: memory allocation
580: M*/
581: #if defined(PETSC_USE_BOPT_g)
582: #define PetscFree4(m1,m2,m3,m4) (PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1))
583: #else
584: #define PetscFree4(m1,m2,m3,m4) (PetscFree(m1))
585: #endif
587: /*MC
588: PetscFree5 - Frees 5 chunks of memory obtained with PetscMalloc5()
590: Input Parameter:
591: + m1 - memory to free
592: . m2 - 2nd memory to free
593: . m3 - 3rd memory to free
594: . m4 - 4th memory to free
595: - m5 - 5th memory to free
598: Synopsis:
599: PetscErrorCode PetscFree5(void *m1,void *m2,void *m3,void *m4,void *m5)
601: Level: developer
603: Notes: Memory must have been obtained with PetscMalloc5()
605: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5()
607: Concepts: memory allocation
609: M*/
610: #if defined(PETSC_USE_BOPT_g)
611: #define PetscFree5(m1,m2,m3,m4,m5) (PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1))
612: #else
613: #define PetscFree5(m1,m2,m3,m4,m5) (PetscFree(m1))
614: #endif
617: /*MC
618: PetscFree6 - Frees 6 chunks of memory obtained with PetscMalloc6()
620: Input Parameter:
621: + m1 - memory to free
622: . m2 - 2nd memory to free
623: . m3 - 3rd memory to free
624: . m4 - 4th memory to free
625: . m5 - 5th memory to free
626: - m6 - 6th memory to free
629: Synopsis:
630: PetscErrorCode PetscFree6(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6)
632: Level: developer
634: Notes: Memory must have been obtained with PetscMalloc6()
636: .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5(), PetscMalloc6()
638: Concepts: memory allocation
640: M*/
641: #if defined(PETSC_USE_BOPT_g)
642: #define PetscFree6(m1,m2,m3,m4,m5,m6) (PetscFree(m6) || PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1))
643: #else
644: #define PetscFree6(m1,m2,m3,m4,m5,m6) (PetscFree(m1))
645: #endif
647: EXTERN PetscErrorCode (*PetscTrMalloc)(size_t,int,const char[],const char[],const char[],void**);
648: EXTERN PetscErrorCode (*PetscTrFree)(void*,int,const char[],const char[],const char[]);
649: EXTERN PetscErrorCode PetscSetMalloc(PetscErrorCode (*)(size_t,int,const char[],const char[],const char[],void**),PetscErrorCode (*)(void*,int,const char[],const char[],const char[]));
650: EXTERN PetscErrorCode PetscClearMalloc(void);
652: /*
653: Routines for tracing memory corruption/bleeding with default PETSc
654: memory allocation
655: */
656: EXTERN PetscErrorCode PetscTrDump(FILE *);
657: EXTERN PetscErrorCode PetscTrSpace(PetscLogDouble *,PetscLogDouble *,PetscLogDouble *);
658: EXTERN PetscErrorCode PetscTrValid(int,const char[],const char[],const char[]);
659: EXTERN PetscErrorCode PetscTrDebug(PetscTruth);
660: EXTERN PetscErrorCode PetscTrLog(void);
661: EXTERN PetscErrorCode PetscTrLogDump(FILE *);
662: EXTERN PetscErrorCode PetscGetResidentSetSize(PetscLogDouble *);
664: /*
665: Variable type where we stash PETSc object pointers in Fortran.
666: Assumes that sizeof(long) == sizeof(void*)which is true on
667: all machines that we know.
668: */
669: #define PetscFortranAddr long
671: /*E
672: PetscDataType - Used for handling different basic data types.
674: Level: beginner
676: .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(),
677: PetscDataTypeGetSize(), PetscDataTypeGetName()
679: E*/
680: typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2,
681: PETSC_LONG = 3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5,
682: PETSC_CHAR = 6,PETSC_LOGICAL = 7} PetscDataType;
683: #if defined(PETSC_USE_COMPLEX)
684: #define PETSC_SCALAR PETSC_COMPLEX
685: #else
686: #if defined(PETSC_USE_SINGLE)
687: #define PETSC_SCALAR PETSC_FLOAT
688: #else
689: #define PETSC_SCALAR PETSC_DOUBLE
690: #endif
691: #endif
692: #if defined(PETSC_USE_SINGLE)
693: #define PETSC_REAL PETSC_FLOAT
694: #else
695: #define PETSC_REAL PETSC_DOUBLE
696: #endif
697: #define PETSC_FORTRANADDR PETSC_LONG
699: EXTERN PetscErrorCode PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*);
700: EXTERN PetscErrorCode PetscDataTypeGetSize(PetscDataType,PetscInt*);
701: EXTERN PetscErrorCode PetscDataTypeGetName(PetscDataType,const char*[]);
703: /*
704: Basic memory and string operations. These are usually simple wrappers
705: around the basic Unix system calls, but a few of them have additional
706: functionality and/or error checking.
707: */
708: EXTERN PetscErrorCode PetscMemcpy(void*,const void *,size_t);
709: EXTERN PetscErrorCode PetscBitMemcpy(void*,PetscInt,const void*,PetscInt,PetscInt,PetscDataType);
710: EXTERN PetscErrorCode PetscMemmove(void*,void *,size_t);
711: EXTERN PetscErrorCode PetscMemzero(void*,size_t);
712: EXTERN PetscErrorCode PetscMemcmp(const void*,const void*,size_t,PetscTruth *);
713: EXTERN PetscErrorCode PetscStrlen(const char[],size_t*);
714: EXTERN PetscErrorCode PetscStrcmp(const char[],const char[],PetscTruth *);
715: EXTERN PetscErrorCode PetscStrgrt(const char[],const char[],PetscTruth *);
716: EXTERN PetscErrorCode PetscStrcasecmp(const char[],const char[],PetscTruth*);
717: EXTERN PetscErrorCode PetscStrncmp(const char[],const char[],size_t,PetscTruth*);
718: EXTERN PetscErrorCode PetscStrcpy(char[],const char[]);
719: EXTERN PetscErrorCode PetscStrcat(char[],const char[]);
720: EXTERN PetscErrorCode PetscStrncat(char[],const char[],size_t);
721: EXTERN PetscErrorCode PetscStrncpy(char[],const char[],size_t);
722: EXTERN PetscErrorCode PetscStrchr(const char[],char,char *[]);
723: EXTERN PetscErrorCode PetscStrtolower(char[]);
724: EXTERN PetscErrorCode PetscStrrchr(const char[],char,char *[]);
725: EXTERN PetscErrorCode PetscStrstr(const char[],const char[],char *[]);
726: EXTERN PetscErrorCode PetscStrallocpy(const char[],char *[]);
727: EXTERN PetscErrorCode PetscStrreplace(MPI_Comm,const char[],char[],size_t);
728: #define PetscStrfree(a) ((a) ? PetscFree(a) : 0)
729: /*S
730: PetscToken - 'Token' used for managing tokenizing strings
732: Level: intermediate
734: .seealso: PetscTokenCreate(), PetscTokenFind(), PetscTokenDestroy()
735: S*/
736: typedef struct {char token;char *array;char *current;} PetscToken;
738: EXTERN PetscErrorCode PetscTokenCreate(const char[],const char,PetscToken**);
739: EXTERN PetscErrorCode PetscTokenFind(PetscToken*,char *[]);
740: EXTERN PetscErrorCode PetscTokenDestroy(PetscToken*);
742: /*
743: These are MPI operations for MPI_Allreduce() etc
744: */
745: EXTERN MPI_Op PetscMaxSum_Op;
746: #if defined(PETSC_USE_COMPLEX)
747: EXTERN MPI_Op PetscSum_Op;
748: #else
749: #define PetscSum_Op MPI_SUM
750: #endif
751: EXTERN PetscErrorCode PetscMaxSum(MPI_Comm,const PetscInt[],PetscInt*,PetscInt*);
753: /*S
754: PetscObject - any PETSc object, PetscViewer, Mat, Vec, KSP etc
756: Level: beginner
758: Note: This is the base class from which all objects appear.
760: .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName()
761: S*/
762: typedef struct _p_PetscObject* PetscObject;
764: /*S
765: PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed
766: by string name
768: Level: advanced
770: .seealso: PetscFListAdd(), PetscFListDestroy()
771: S*/
772: typedef struct _PetscFList *PetscFList;
774: #include petscviewer.h
775: #include petscoptions.h
777: EXTERN PetscErrorCode PetscLogInfoAllow(PetscTruth,const char []);
778: EXTERN PetscErrorCode PetscShowMemoryUsage(PetscViewer,const char[]);
779: EXTERN PetscErrorCode PetscGetTime(PetscLogDouble*);
780: EXTERN PetscErrorCode PetscGetCPUTime(PetscLogDouble*);
781: EXTERN PetscErrorCode PetscSleep(int);
783: /*
784: Initialization of PETSc
785: */
786: EXTERN PetscErrorCode PetscInitialize(int*,char***,const char[],const char[]);
787: EXTERN PetscErrorCode PetscInitializeNoArguments(void);
788: EXTERN PetscErrorCode PetscInitialized(PetscTruth *);
789: EXTERN PetscErrorCode PetscFinalize(void);
790: EXTERN PetscErrorCode PetscInitializeFortran(void);
791: EXTERN PetscErrorCode PetscGetArgs(int*,char ***);
792: EXTERN PetscErrorCode PetscEnd(void);
794: typedef void (**PetscVoidFunction)(void);
796: /*
797: PetscTryMethod - Queries an object for a method, if it exists then calls it.
798: These are intended to be used only inside PETSc functions.
799: */
800: #define PetscTryMethod(obj,A,B,C) \
801: 0;{ PetscErrorCode (*f)B, __ierr; \
802: __PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);CHKERRQ(__ierr); \
803: if (f) {__(*f)C;CHKERRQ(__ierr);}\
804: }
805: #define PetscUseMethod(obj,A,B,C) \
806: 0;{ PetscErrorCode (*f)B, __ierr; \
807: __PetscObjectQueryFunction((PetscObject)obj,A,(PetscVoidFunction)&f);CHKERRQ(__ierr); \
808: if (f) {__(*f)C;CHKERRQ(__ierr);}\
809: else {SETERRQ1(PETSC_ERR_SUP,"Cannot locate function %s in object",A);} \
810: }
811: /*
812: Functions that can act on any PETSc object.
813: */
814: EXTERN PetscErrorCode PetscObjectDestroy(PetscObject);
815: EXTERN PetscErrorCode PetscObjectExists(PetscObject,PetscTruth*);
816: EXTERN PetscErrorCode PetscObjectGetComm(PetscObject,MPI_Comm *);
817: EXTERN PetscErrorCode PetscObjectGetCookie(PetscObject,int *);
818: EXTERN PetscErrorCode PetscObjectGetType(PetscObject,int *);
819: EXTERN PetscErrorCode PetscObjectSetName(PetscObject,const char[]);
820: EXTERN PetscErrorCode PetscObjectGetName(PetscObject,char*[]);
821: EXTERN PetscErrorCode PetscObjectReference(PetscObject);
822: EXTERN PetscErrorCode PetscObjectGetReference(PetscObject,PetscInt*);
823: EXTERN PetscErrorCode PetscObjectDereference(PetscObject);
824: EXTERN PetscErrorCode PetscObjectGetNewTag(PetscObject,PetscMPIInt *);
825: EXTERN PetscErrorCode PetscCommGetNewTag(MPI_Comm,PetscMPIInt *);
826: EXTERN PetscErrorCode PetscObjectView(PetscObject,PetscViewer);
827: EXTERN PetscErrorCode PetscObjectCompose(PetscObject,const char[],PetscObject);
828: EXTERN PetscErrorCode PetscObjectQuery(PetscObject,const char[],PetscObject *);
829: EXTERN PetscErrorCode PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)(void));
833: /*MC
834: PetscObjectComposeFunctionDynamic - Associates a function with a given PETSc object.
835:
836: Collective on PetscObject
838: Input Parameters:
839: + obj - the PETSc object; this must be cast with a (PetscObject), for example,
840: PetscObjectCompose((PetscObject)mat,...);
841: . name - name associated with the child function
842: . fname - name of the function
843: - ptr - function pointer (or PETSC_NULL if using dynamic libraries)
845: Level: advanced
847: Synopsis:
848: PetscErrorCode PetscObjectComposeFunctionDynamic(PetscObject obj,const char name[],const char fname[],void *ptr)
850: Notes:
851: To remove a registered routine, pass in a PETSC_NULL rname and fnc().
853: PetscObjectComposeFunctionDynamic() can be used with any PETSc object (such as
854: Mat, Vec, KSP, SNES, etc.) or any user-provided object.
857: work in C++/complex with dynamic link libraries (PETSC_USE_DYNAMIC_LIBRARIES)
858: enabled.
860: Concepts: objects^composing functions
861: Concepts: composing functions
862: Concepts: functions^querying
863: Concepts: objects^querying
864: Concepts: querying objects
866: .seealso: PetscObjectQueryFunction()
867: M*/
868: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
869: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0)
870: #else
871: #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(FCNVOID)(d))
872: #endif
874: EXTERN PetscErrorCode PetscObjectQueryFunction(PetscObject,const char[],void (**)(void));
875: EXTERN PetscErrorCode PetscObjectSetOptionsPrefix(PetscObject,const char[]);
876: EXTERN PetscErrorCode PetscObjectAppendOptionsPrefix(PetscObject,const char[]);
877: EXTERN PetscErrorCode PetscObjectPrependOptionsPrefix(PetscObject,const char[]);
878: EXTERN PetscErrorCode PetscObjectGetOptionsPrefix(PetscObject,char*[]);
879: EXTERN PetscErrorCode PetscObjectPublish(PetscObject);
880: EXTERN PetscErrorCode PetscObjectChangeTypeName(PetscObject,const char[]);
881: EXTERN PetscErrorCode PetscObjectRegisterDestroy(PetscObject);
882: EXTERN PetscErrorCode PetscObjectRegisterDestroyAll(void);
883: EXTERN PetscErrorCode PetscObjectName(PetscObject);
884: EXTERN PetscErrorCode PetscTypeCompare(PetscObject,const char[],PetscTruth*);
886: /*
887: Defines PETSc error handling.
888: */
889: #include petscerror.h
891: /*S
892: PetscOList - Linked list of PETSc objects, accessable by string name
894: Level: advanced
896: .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind()
897: S*/
898: typedef struct _PetscOList *PetscOList;
900: EXTERN PetscErrorCode PetscOListDestroy(PetscOList *);
901: EXTERN PetscErrorCode PetscOListFind(PetscOList,const char[],PetscObject*);
902: EXTERN PetscErrorCode PetscOListReverseFind(PetscOList,PetscObject,char**);
903: EXTERN PetscErrorCode PetscOListAdd(PetscOList *,const char[],PetscObject);
904: EXTERN PetscErrorCode PetscOListDuplicate(PetscOList,PetscOList *);
906: /*
907: Dynamic library lists. Lists of names of routines in dynamic
908: link libraries that will be loaded as needed.
909: */
910: EXTERN PetscErrorCode PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void));
911: EXTERN PetscErrorCode PetscFListDestroy(PetscFList*);
912: EXTERN PetscErrorCode PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)(void));
913: EXTERN PetscErrorCode PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],const char[],const char[],PetscFList);
914: #if defined(PETSC_USE_DYNAMIC_LIBRARIES)
915: #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0)
916: #else
917: #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c)
918: #endif
919: EXTERN PetscErrorCode PetscFListDuplicate(PetscFList,PetscFList *);
920: EXTERN PetscErrorCode PetscFListView(PetscFList,PetscViewer);
921: EXTERN PetscErrorCode PetscFListConcat(const char [],const char [],char []);
922: EXTERN PetscErrorCode PetscFListGet(PetscFList,char ***,int*);
924: /*S
925: PetscDLLibraryList - Linked list of dynamics libraries to search for functions
927: Level: advanced
929: PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries
931: .seealso: PetscDLLibraryOpen()
932: S*/
933: typedef struct _PetscDLLibraryList *PetscDLLibraryList;
935: EXTERN PetscErrorCode PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *);
936: EXTERN PetscErrorCode PetscDLLibraryOpen(MPI_Comm,const char[],void **);
937: EXTERN PetscErrorCode PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **);
938: EXTERN PetscErrorCode PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]);
939: EXTERN PetscErrorCode PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]);
940: EXTERN PetscErrorCode PetscDLLibraryClose(PetscDLLibraryList);
941: EXTERN PetscErrorCode PetscDLLibraryPrintPath(void);
942: EXTERN PetscErrorCode PetscDLLibraryGetInfo(void*,const char[],const char *[]);
944: /*
945: Mechanism for translating PETSc object representations between languages
946: Not currently used.
947: */
948: typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage;
949: #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C
950: EXTERN PetscErrorCode PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *);
951: EXTERN PetscErrorCode PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **);
953: /*
954: Useful utility routines
955: */
956: EXTERN PetscErrorCode PetscSplitOwnership(MPI_Comm,PetscInt*,PetscInt*);
957: EXTERN PetscErrorCode PetscSplitOwnershipBlock(MPI_Comm,PetscInt,PetscInt*,PetscInt*);
958: EXTERN PetscErrorCode PetscSequentialPhaseBegin(MPI_Comm,PetscMPIInt);
959: EXTERN PetscErrorCode PetscSequentialPhaseEnd(MPI_Comm,PetscMPIInt);
960: EXTERN PetscErrorCode PetscBarrier(PetscObject);
961: EXTERN PetscErrorCode PetscMPIDump(FILE*);
963: #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE)
964: /*
965: Defines basic graphics available from PETSc.
966: */
967: #include petscdraw.h
969: /*
970: Defines the base data structures for all PETSc objects
971: */
972: #include petschead.h
974: /*
975: Defines PETSc profiling.
976: */
977: #include petsclog.h
979: /*
980: For locking, unlocking and destroying AMS memories associated with
981: PETSc objects. Not currently used.
982: */
983: #define PetscPublishAll(v) 0
984: #define PetscObjectTakeAccess(obj) 0
985: #define PetscObjectGrantAccess(obj) 0
986: #define PetscObjectDepublish(obj) 0
990: /*
991: This code allows one to pass a MPI communicator between
992: C and Fortran. MPI 2.0 defines a standard API for doing this.
993: The code here is provided to allow PETSc to work with MPI 1.1
994: standard MPI libraries.
995: */
996: EXTERN PetscErrorCode MPICCommToFortranComm(MPI_Comm,int *);
997: EXTERN PetscErrorCode MPIFortranCommToCComm(int,MPI_Comm*);
999: /*
1000: Simple PETSc parallel IO for ASCII printing
1001: */
1002: EXTERN PetscErrorCode PetscFixFilename(const char[],char[]);
1003: EXTERN PetscErrorCode PetscFOpen(MPI_Comm,const char[],const char[],FILE**);
1004: EXTERN PetscErrorCode PetscFClose(MPI_Comm,FILE*);
1005: EXTERN PetscErrorCode PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4);
1006: EXTERN PetscErrorCode PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3);
1008: /* These are used internally by PETSc ASCII IO routines*/
1009: #include <stdarg.h>
1010: EXTERN PetscErrorCode PetscVSNPrintf(char*,size_t,const char*,va_list);
1011: EXTERN PetscErrorCode PetscVFPrintf(FILE*,const char*,va_list);
1013: /*MC
1014: PetscErrorPrintf - Prints error messages.
1016: Not Collective
1018: Synopsis:
1019: PetscErrorCode (*PetscErrorPrintf)(const char format[],...);
1021: Input Parameters:
1022: . format - the usual printf() format string
1024: Options Database Keys:
1025: . -error_output_stderr - cause error messages to be printed to stderr instead of the
1026: (default) stdout
1029: Level: developer
1031: Fortran Note:
1032: This routine is not supported in Fortran.
1034: Concepts: error messages^printing
1035: Concepts: printing^error messages
1037: .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscHelpPrintf()
1038: M*/
1039: EXTERN PetscErrorCode (*PetscErrorPrintf)(const char[],...);
1041: /*MC
1042: PetscHelpPrintf - Prints help messages.
1044: Not Collective
1046: Synopsis:
1047: PetscErrorCode (*PetscHelpPrintf)(const char format[],...);
1049: Input Parameters:
1050: . format - the usual printf() format string
1052: Level: developer
1054: Fortran Note:
1055: This routine is not supported in Fortran.
1057: Concepts: help messages^printing
1058: Concepts: printing^help messages
1060: .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscErrorPrintf()
1061: M*/
1062: EXTERN PetscErrorCode (*PetscHelpPrintf)(MPI_Comm,const char[],...);
1064: EXTERN PetscErrorCode PetscPOpen(MPI_Comm,const char[],const char[],const char[],FILE **);
1065: EXTERN PetscErrorCode PetscPClose(MPI_Comm,FILE*);
1066: EXTERN PetscErrorCode PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3);
1067: EXTERN PetscErrorCode PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4);
1068: EXTERN PetscErrorCode PetscSynchronizedFlush(MPI_Comm);
1069: EXTERN PetscErrorCode PetscSynchronizedFGets(MPI_Comm,FILE*,size_t,char[]);
1070: EXTERN PetscErrorCode PetscStartMatlab(MPI_Comm,const char[],const char[],FILE**);
1071: EXTERN PetscErrorCode PetscStartJava(MPI_Comm,const char[],const char[],FILE**);
1072: EXTERN PetscErrorCode PetscGetPetscDir(const char*[]);
1074: EXTERN PetscErrorCode PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*);
1075: /*S
1076: PetscObjectContainer - Simple PETSc object that contains a pointer to any required data
1078: Level: advanced
1080: .seealso: PetscObject, PetscObjectContainerCreate()
1081: S*/
1082: typedef struct _p_PetscObjectContainer* PetscObjectContainer;
1083: EXTERN PetscErrorCode PetscObjectContainerGetPointer(PetscObjectContainer,void **);
1084: EXTERN PetscErrorCode PetscObjectContainerSetPointer(PetscObjectContainer,void *);
1085: EXTERN PetscErrorCode PetscObjectContainerDestroy(PetscObjectContainer);
1086: EXTERN PetscErrorCode PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *);
1088: /*
1089: For incremental debugging
1090: */
1092: EXTERN PetscErrorCode PetscCompareDouble(double);
1093: EXTERN PetscErrorCode PetscCompareScalar(PetscScalar);
1094: EXTERN PetscErrorCode PetscCompareInt(PetscInt);
1096: /*
1097: For use in debuggers
1098: */
1100: EXTERN PetscErrorCode PetscIntView(PetscInt,PetscInt[],PetscViewer);
1101: EXTERN PetscErrorCode PetscRealView(PetscInt,PetscReal[],PetscViewer);
1102: EXTERN PetscErrorCode PetscScalarView(PetscInt,PetscScalar[],PetscViewer);
1104: /*
1105: Allows accessing Matlab Engine
1106: */
1107: #include petscmatlab.h
1109: /*
1110: C code optimization is often enhanced by telling the compiler
1111: that certain pointer arguments to functions are not aliased to
1112: to other arguments. This is not yet ANSI C standard so we define
1113: the macro "restrict" to indicate that the variable is not aliased
1114: to any other argument.
1115: */
1116: #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus)
1117: #define restrict _Restrict
1118: #else
1119: #if defined(restrict)
1120: #undef restrict
1121: #endif
1122: #define restrict
1123: #endif
1125: /*
1126: Determine if some of the kernel computation routines use
1127: Fortran (rather than C) for the numerical calculations. On some machines
1128: and compilers (like complex numbers) the Fortran version of the routines
1129: is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS
1130: would be set in the petscconf.h file
1131: */
1132: #if defined(PETSC_USE_FORTRAN_KERNELS)
1134: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ)
1135: #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ
1136: #endif
1138: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ)
1139: #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ
1140: #endif
1142: #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM)
1143: #define PETSC_USE_FORTRAN_KERNEL_NORM
1144: #endif
1146: #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY)
1147: #define PETSC_USE_FORTRAN_KERNEL_MAXPY
1148: #endif
1150: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ)
1151: #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ
1152: #endif
1154: #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ)
1155: #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ
1156: #endif
1158: #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ)
1159: #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ
1160: #endif
1162: #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ)
1163: #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ
1164: #endif
1166: #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT)
1167: #define PETSC_USE_FORTRAN_KERNEL_MDOT
1168: #endif
1170: #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY)
1171: #define PETSC_USE_FORTRAN_KERNEL_XTIMESY
1172: #endif
1174: #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX)
1175: #define PETSC_USE_FORTRAN_KERNEL_AYPX
1176: #endif
1178: #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY)
1179: #define PETSC_USE_FORTRAN_KERNEL_WAXPY
1180: #endif
1182: #endif
1184: /*
1185: Macros for indicating code that should be compiled with a C interface,
1186: rather than a C++ interface. Any routines that are dynamically loaded
1187: (such as the PCCreate_XXX() routines) must be wrapped so that the name
1188: mangler does not change the functions symbol name. This just hides the
1190: */
1191: #if defined(__cplusplus)
1194: #else
1197: #endif
1199: /* --------------------------------------------------------------------*/
1201: /*M
1202: size - integer variable used to contain the number of processors in
1203: the relevent MPI_Comm
1205: Level: beginner
1207: .seealso: rank, comm
1208: M*/
1210: /*M
1211: rank - integer variable used to contain the number of this processor relative
1212: to all in the relevent MPI_Comm
1214: Level: beginner
1216: .seealso: size, comm
1217: M*/
1219: /*M
1220: comm - MPI_Comm used in the current routine or object
1222: Level: beginner
1224: .seealso: size, rank
1225: M*/
1227: /*M
1228: MPI_Comm - the basic object used by MPI to determine which processes are involved in a
1229: communication
1231: Level: beginner
1233: Note: This manual page is a place-holder because MPICH does not have a manual page for MPI_Comm
1235: .seealso: size, rank, comm, PETSC_COMM_WORLD, PETSC_COMM_SELF
1236: M*/
1238: /*M
1239: PetscScalar - PETSc type that represents either a double precision real number or
1240: a double precision complex number if the code is compiled with BOPT=g_complex or O_complex
1242: Level: beginner
1244: .seealso: PetscReal, PassiveReal, PassiveScalar
1245: M*/
1247: /*M
1248: PetscReal - PETSc type that represents a double precision real number
1250: Level: beginner
1252: .seealso: PetscScalar, PassiveReal, PassiveScalar
1253: M*/
1255: /*M
1256: PassiveScalar - PETSc type that represents either a double precision real number or
1257: a double precision complex number if the code is compiled with BOPT=g_complex or O_complex
1259: Level: beginner
1261: This is the same as a PetscScalar except in code that is automatically differentiated it is
1262: treated as a constant (not an indendent or dependent variable)
1264: .seealso: PetscReal, PassiveReal, PetscScalar
1265: M*/
1267: /*M
1268: PassiveReal - PETSc type that represents a double precision real number
1270: Level: beginner
1272: This is the same as a PetscReal except in code that is automatically differentiated it is
1273: treated as a constant (not an indendent or dependent variable)
1275: .seealso: PetscScalar, PetscReal, PassiveScalar
1276: M*/
1278: /*M
1279: MPIU_SCALAR - MPI datatype corresponding to PetscScalar
1281: Level: beginner
1283: Note: In MPI calls that require an MPI datatype that matches a PetscScalar or array of PetscScalars
1284: pass this value
1286: .seealso: PetscReal, PassiveReal, PassiveScalar, PetscScalar
1287: M*/
1289: /*
1290: The IBM include files define hz, here we hide it so that it may be used
1291: as a regular user variable.
1292: */
1293: #if defined(hz)
1294: #undef hz
1295: #endif
1297: /* For arrays that contain filenames or paths */
1300: #if defined(PETSC_HAVE_LIMITS_H)
1301: #include <limits.h>
1302: #endif
1303: #if defined(PETSC_HAVE_SYS_PARAM_H)
1304: #include <sys/param.h>
1305: #endif
1306: #if defined(PETSC_HAVE_SYS_TYPES_H)
1307: #include <sys/types.h>
1308: #endif
1309: #if defined(MAXPATHLEN)
1310: # define PETSC_MAX_PATH_LEN MAXPATHLEN
1311: #elif defined(MAX_PATH)
1312: # define PETSC_MAX_PATH_LEN MAX_PATH
1313: #elif defined(_MAX_PATH)
1314: # define PETSC_MAX_PATH_LEN _MAX_PATH
1315: #else
1316: # define PETSC_MAX_PATH_LEN 4096
1317: #endif
1320: #endif