Actual source code: petscsystypes.h
1: #if !defined(PETSCSYSTYPES_H)
2: #define PETSCSYSTYPES_H
4: #include <petscconf.h>
5: #include <petscfix.h>
7: /*MC
8: PetscErrorCode - datatype used for return error code from almost all PETSc functions
10: Level: beginner
12: .seealso: CHKERRQ, SETERRQ
13: M*/
14: typedef int PetscErrorCode;
16: /*MC
18: PetscClassId - A unique id used to identify each PETSc class.
20: Notes:
21: Use PetscClassIdRegister() to obtain a new value for a new class being created. Usually
22: XXXInitializePackage() calls it for each class it defines.
24: Developer Notes:
25: Internal integer stored in the _p_PetscObject data structure.
26: These are all computed by an offset from the lowest one, PETSC_SMALLEST_CLASSID.
28: Level: developer
30: .seealso: PetscClassIdRegister(), PetscLogEventRegister(), PetscHeaderCreate()
31: M*/
32: typedef int PetscClassId;
34: /*MC
35: PetscMPIInt - datatype used to represent 'int' parameters to MPI functions.
37: Level: intermediate
39: Notes:
40: usually this is the same as PetscInt, but if PETSc was built with --with-64-bit-indices but
41: standard C/Fortran integers are 32 bit then this is NOT the same as PetscInt; it remains 32 bit.
43: PetscMPIIntCast(a,&b) checks if the given PetscInt a will fit in a PetscMPIInt, if not it
44: generates a PETSC_ERR_ARG_OUTOFRANGE error.
46: .seealso: PetscBLASInt, PetscInt, PetscMPIIntCast()
48: M*/
49: typedef int PetscMPIInt;
51: /*MC
52: PetscEnum - datatype used to pass enum types within PETSc functions.
54: Level: intermediate
56: .seealso: PetscOptionsGetEnum(), PetscOptionsEnum(), PetscBagRegisterEnum()
57: M*/
58: typedef enum { ENUM_DUMMY } PetscEnum;
60: typedef short PetscShort;
61: typedef char PetscChar;
62: typedef float PetscFloat;
64: /*MC
65: PetscInt - PETSc type that represents an integer, used primarily to
66: represent size of arrays and indexing into arrays. Its size can be configured with the option --with-64-bit-indices to be either 32-bit (default) or 64-bit.
68: Notes:
69: For MPI calls that require datatypes, use MPIU_INT as the datatype for PetscInt. It will automatically work correctly regardless of the size of PetscInt.
71: Level: beginner
73: .seealso: PetscBLASInt, PetscMPIInt, PetscReal, PetscScalar, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT
74: M*/
76: #if defined(PETSC_HAVE_STDINT_H)
77: # include <stdint.h>
78: #endif
79: #if defined (PETSC_HAVE_INTTYPES_H)
80: # if !defined(__STDC_FORMAT_MACROS)
81: # define __STDC_FORMAT_MACROS /* required for using PRId64 from c++ */
82: # endif
83: # include <inttypes.h>
84: # if !defined(PRId64)
85: # define PRId64 "ld"
86: # endif
87: #endif
89: #if defined(PETSC_HAVE_STDINT_H) && defined(PETSC_HAVE_INTTYPES_H) && defined(PETSC_HAVE_MPI_INT64_T) /* MPI_INT64_T is not guaranteed to be a macro */
90: typedef int64_t PetscInt64;
91: #elif (PETSC_SIZEOF_LONG_LONG == 8)
92: typedef long long PetscInt64;
93: #elif defined(PETSC_HAVE___INT64)
94: typedef __int64 PetscInt64;
95: #else
96: # error "cannot determine PetscInt64 type"
97: #endif
99: #if defined(PETSC_USE_64BIT_INDICES)
100: typedef PetscInt64 PetscInt;
101: #else
102: typedef int PetscInt;
103: #endif
105: /*MC
106: PetscBLASInt - datatype used to represent 'int' parameters to BLAS/LAPACK functions.
108: Notes:
109: Usually this is the same as PetscInt, but if PETSc was built with --with-64-bit-indices but
110: standard C/Fortran integers are 32 bit then this is NOT the same as PetscInt it remains 32 bit
111: (except on very rare BLAS/LAPACK implementations that support 64 bit integers see the notes below).
113: PetscErrorCode PetscBLASIntCast(a,&b) checks if the given PetscInt a will fit in a PetscBLASInt, if not it
114: generates a PETSC_ERR_ARG_OUTOFRANGE error
116: Installation Notes:
117: ./configure automatically determines the size of the integers used by BLAS/LAPACK except when --with-batch is used
118: in that situation one must know (by some other means) if the integers used by BLAS/LAPACK are 64 bit and if so pass the flag --known-64-bit-blas-indice
120: MATLAB ships with BLAS and LAPACK that use 64 bit integers, for example if you run ./configure with, the option
121: --with-blaslapack-lib=[/Applications/MATLAB_R2010b.app/bin/maci64/libmwblas.dylib,/Applications/MATLAB_R2010b.app/bin/maci64/libmwlapack.dylib]
123: MKL ships with both 32 and 64 bit integer versions of the BLAS and LAPACK. If you pass the flag -with-64-bit-blas-indices PETSc will link
124: against the 64 bit version, otherwise it use the 32 bit version
126: OpenBLAS can be built to use 64 bit integers. The ./configure options --download-openblas -with-64-bit-blas-indices will build a 64 bit integer version
128: External packages such as hypre, ML, SuperLU etc do not provide any support for passing 64 bit integers to BLAS/LAPACK so cannot
129: be used with PETSc when PETSc links against 64 bit integer BLAS/LAPACK. ./configure will generate an error if you attempt to link PETSc against any of
130: these external libraries while using 64 bit integer BLAS/LAPACK.
132: Level: intermediate
134: .seealso: PetscMPIInt, PetscInt, PetscBLASIntCast()
136: M*/
137: #if defined(PETSC_HAVE_64BIT_BLAS_INDICES)
138: typedef PetscInt64 PetscBLASInt;
139: #else
140: typedef int PetscBLASInt;
141: #endif
143: /*MC
144: PetscCuBLASInt - datatype used to represent 'int' parameters to cuBLAS/cuSOLVER functions.
146: Notes:
147: As of this writing PetscCuBLASInt is always the system `int`.
149: PetscErrorCode PetscCuBLASIntCast(a,&b) checks if the given PetscInt a will fit in a PetscCuBLASInt, if not it
150: generates a PETSC_ERR_ARG_OUTOFRANGE error
152: Level: intermediate
154: .seealso: PetscBLASInt, PetscMPIInt, PetscInt, PetscCuBLASIntCast()
156: M*/
157: typedef int PetscCuBLASInt;
159: /*E
160: PetscBool - Logical variable. Actually an int in C and a logical in Fortran.
162: Level: beginner
164: Developer Note:
165: Why have PetscBool , why not use bool in C? The problem is that K and R C, C99 and C++ all have different mechanisms for
166: boolean values. It is not easy to have a simple macro that that will work properly in all circumstances with all three mechanisms.
168: .seealso: PETSC_TRUE, PETSC_FALSE, PetscNot()
169: E*/
170: typedef enum { PETSC_FALSE,PETSC_TRUE } PetscBool;
172: /*MC
173: PetscReal - PETSc type that represents a real number version of PetscScalar
175: Notes:
176: For MPI calls that require datatypes, use MPIU_REAL as the datatype for PetscScalar and MPIU_SUM, MPIU_MAX, etc. for operations.
177: They will automatically work correctly regardless of the size of PetscReal.
179: See PetscScalar for details on how to ./configure the size of PetscReal.
181: Level: beginner
183: .seealso: PetscScalar, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT
184: M*/
186: #if defined(PETSC_USE_REAL_SINGLE)
187: typedef float PetscReal;
188: #elif defined(PETSC_USE_REAL_DOUBLE)
189: typedef double PetscReal;
190: #elif defined(PETSC_USE_REAL___FLOAT128)
191: # if defined(__cplusplus)
192: extern "C" {
193: # endif
194: # include <quadmath.h>
195: # if defined(__cplusplus)
196: }
197: # endif
198: typedef __float128 PetscReal;
199: #elif defined(PETSC_USE_REAL___FP16)
200: typedef __fp16 PetscReal;
201: #endif /* PETSC_USE_REAL_* */
203: /*MC
204: PetscComplex - PETSc type that represents a complex number with precision matching that of PetscReal.
206: Synopsis:
207: #include <petscsys.h>
208: PetscComplex number = 1. + 2.*PETSC_i;
210: Notes:
211: For MPI calls that require datatypes, use MPIU_COMPLEX as the datatype for PetscComplex and MPIU_SUM etc for operations.
212: They will automatically work correctly regardless of the size of PetscComplex.
214: See PetscScalar for details on how to ./configure the size of PetscReal
216: Complex numbers are automatically available if PETSc was able to find a working complex implementation
218: Petsc has a 'fix' for complex numbers to support expressions such as std::complex<PetscReal> + PetscInt, which are not supported by the standard
219: C++ library, but are convenient for petsc users. If the C++ compiler is able to compile code in petsccxxcomplexfix.h (This is checked by
220: configure), we include petsccxxcomplexfix.h to provide this convenience.
222: If the fix causes conflicts, or one really does not want this fix for a particular C++ file, one can define PETSC_SKIP_CXX_COMPLEX_FIX
223: at the beginning of the C++ file to skip the fix.
225: Level: beginner
227: .seealso: PetscReal, PetscScalar, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT, PETSC_i
228: M*/
229: #if !defined(PETSC_SKIP_COMPLEX)
230: # if defined(PETSC_CLANGUAGE_CXX)
231: # if !defined(PETSC_USE_REAL___FP16) && !defined(PETSC_USE_REAL___FLOAT128)
232: # if defined(__cplusplus) && defined(PETSC_HAVE_CXX_COMPLEX) /* enable complex for library code */
233: # define PETSC_HAVE_COMPLEX 1
234: # elif !defined(__cplusplus) && defined(PETSC_HAVE_C99_COMPLEX) && defined(PETSC_HAVE_CXX_COMPLEX) /* User code only - conditional on libary code complex support */
235: # define PETSC_HAVE_COMPLEX 1
236: # endif
237: # elif defined(PETSC_USE_REAL___FLOAT128) && defined(PETSC_HAVE_C99_COMPLEX)
238: # define PETSC_HAVE_COMPLEX 1
239: # endif
240: # else /* !PETSC_CLANGUAGE_CXX */
241: # if !defined(PETSC_USE_REAL___FP16)
242: # if !defined(__cplusplus) && defined(PETSC_HAVE_C99_COMPLEX) /* enable complex for library code */
243: # define PETSC_HAVE_COMPLEX 1
244: # elif defined(__cplusplus) && defined(PETSC_HAVE_C99_COMPLEX) && defined(PETSC_HAVE_CXX_COMPLEX) /* User code only - conditional on libary code complex support */
245: # define PETSC_HAVE_COMPLEX 1
246: # endif
247: # endif
248: # endif /* PETSC_CLANGUAGE_CXX */
249: #endif /* !PETSC_SKIP_COMPLEX */
251: #if defined(PETSC_HAVE_COMPLEX)
252: #if defined(__cplusplus) /* C++ complex support */
253: /* Locate a C++ complex template library */
254: #if defined(PETSC_DESIRE_KOKKOS_COMPLEX) /* Defined in petscvec_kokkos.hpp for *.kokkos.cxx files */
255: #define petsccomplexlib Kokkos
256: #include <Kokkos_Complex.hpp>
257: #elif defined(__CUDACC__) || defined(__HIPCC__)
258: #define petsccomplexlib thrust
259: #include <thrust/complex.h>
260: #elif defined(PETSC_USE_REAL___FLOAT128)
261: #include <complex.h>
262: #else
263: #define petsccomplexlib std
264: #include <complex>
265: #endif
267: /* Define PetscComplex based on the precision */
268: #if defined(PETSC_USE_REAL_SINGLE)
269: typedef petsccomplexlib::complex<float> PetscComplex;
270: #elif defined(PETSC_USE_REAL_DOUBLE)
271: typedef petsccomplexlib::complex<double> PetscComplex;
272: #elif defined(PETSC_USE_REAL___FLOAT128)
273: typedef __complex128 PetscComplex;
274: #endif
276: /* Include a PETSc C++ complex 'fix'. Check PetscComplex manual page for details */
277: #if defined(PETSC_HAVE_CXX_COMPLEX_FIX) && !defined(PETSC_SKIP_CXX_COMPLEX_FIX)
278: #include <petsccxxcomplexfix.h>
279: #endif
280: #else /* c99 complex support */
281: #include <complex.h>
282: #if defined(PETSC_USE_REAL_SINGLE) || defined(PETSC_USE_REAL___FP16)
283: typedef float _Complex PetscComplex;
284: #elif defined(PETSC_USE_REAL_DOUBLE)
285: typedef double _Complex PetscComplex;
286: #elif defined(PETSC_USE_REAL___FLOAT128)
287: typedef __complex128 PetscComplex;
288: #endif /* PETSC_USE_REAL_* */
289: #endif /* !__cplusplus */
290: #endif /* PETSC_HAVE_COMPLEX */
292: /*MC
293: PetscScalar - PETSc type that represents either a double precision real number, a double precision
294: complex number, a single precision real number, a __float128 real or complex or a __fp16 real - if the code is configured
295: with --with-scalar-type=real,complex --with-precision=single,double,__float128,__fp16
297: Notes:
298: For MPI calls that require datatypes, use MPIU_SCALAR as the datatype for PetscScalar and MPIU_SUM, MPIU_MAX etc for operations. They will automatically work correctly regardless of the size of PetscScalar.
300: Level: beginner
302: .seealso: PetscReal, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT, PetscRealPart(), PetscImaginaryPart()
303: M*/
305: #if defined(PETSC_USE_COMPLEX) && defined(PETSC_HAVE_COMPLEX)
306: typedef PetscComplex PetscScalar;
307: #else /* PETSC_USE_COMPLEX */
308: typedef PetscReal PetscScalar;
309: #endif /* PETSC_USE_COMPLEX */
311: /*E
312: PetscCopyMode - Determines how an array or PetscObject passed to certain functions is copied or retained by the aggregate PetscObject
314: Level: beginner
316: For the array input:
317: $ PETSC_COPY_VALUES - the array values are copied into new space, the user is free to reuse or delete the passed in array
318: $ PETSC_OWN_POINTER - the array values are NOT copied, the object takes ownership of the array and will free it later, the user cannot change or
319: $ delete the array. The array MUST have been obtained with PetscMalloc(). Hence this mode cannot be used in Fortran.
320: $ PETSC_USE_POINTER - the array values are NOT copied, the object uses the array but does NOT take ownership of the array. The user cannot use
321: $ the array but the user must delete the array after the object is destroyed.
323: For the PetscObject input:
324: $ PETSC_COPY_VALUES - the input PetscObject is cloned into the aggregate PetscObject; the user is free to reuse/modify the input PetscObject without side effects.
325: $ PETSC_OWN_POINTER - the input PetscObject is referenced by pointer (with reference count), thus should not be modified by the user. (Modification may cause errors or unintended side-effects in this or a future version of PETSc.)
326: For either case above, the input PetscObject should be destroyed by the user when no longer needed (the aggregate object increases its reference count).
327: $ PETSC_USE_POINTER - invalid for PetscObject inputs.
329: E*/
330: typedef enum {PETSC_COPY_VALUES, PETSC_OWN_POINTER, PETSC_USE_POINTER} PetscCopyMode;
332: /*MC
333: PETSC_FALSE - False value of PetscBool
335: Level: beginner
337: Note:
338: Zero integer
340: .seealso: PetscBool, PETSC_TRUE
341: M*/
343: /*MC
344: PETSC_TRUE - True value of PetscBool
346: Level: beginner
348: Note:
349: Nonzero integer
351: .seealso: PetscBool, PETSC_FALSE
352: M*/
354: /*MC
355: PetscLogDouble - Used for logging times
357: Notes:
358: Contains double precision numbers that are not used in the numerical computations, but rather in logging, timing etc.
360: Level: developer
362: M*/
363: typedef double PetscLogDouble;
365: /*E
366: PetscDataType - Used for handling different basic data types.
368: Level: beginner
370: Notes:
371: Use of this should be avoided if one can directly use MPI_Datatype instead.
373: PETSC_INT is the datatype for a PetscInt, regardless of whether it is 4 or 8 bytes.
374: PETSC_REAL, PETSC_COMPLEX and PETSC_SCALAR are the datatypes for PetscReal, PetscComplex and PetscScalar, regardless of their sizes.
376: Developer comment:
377: It would be nice if we could always just use MPI Datatypes, why can we not?
379: If you change any values in PetscDatatype make sure you update their usage in
380: share/petsc/matlab/PetscBagRead.m and share/petsc/matlab/@PetscOpenSocket/read/write.m
382: TODO: Add PETSC_INT32 and remove use of improper PETSC_ENUM
384: .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(),
385: PetscDataTypeGetSize()
387: E*/
388: typedef enum {PETSC_DATATYPE_UNKNOWN = 0,
389: PETSC_DOUBLE = 1, PETSC_COMPLEX = 2, PETSC_LONG = 3, PETSC_SHORT = 4, PETSC_FLOAT = 5,
390: PETSC_CHAR = 6, PETSC_BIT_LOGICAL = 7, PETSC_ENUM = 8, PETSC_BOOL = 9, PETSC___FLOAT128 = 10,
391: PETSC_OBJECT = 11, PETSC_FUNCTION = 12, PETSC_STRING = 13, PETSC___FP16 = 14, PETSC_STRUCT = 15,
392: PETSC_INT = 16, PETSC_INT64 = 17} PetscDataType;
394: #if defined(PETSC_USE_REAL_SINGLE)
395: # define PETSC_REAL PETSC_FLOAT
396: #elif defined(PETSC_USE_REAL_DOUBLE)
397: # define PETSC_REAL PETSC_DOUBLE
398: #elif defined(PETSC_USE_REAL___FLOAT128)
399: # define PETSC_REAL PETSC___FLOAT128
400: #elif defined(PETSC_USE_REAL___FP16)
401: # define PETSC_REAL PETSC___FP16
402: #else
403: # define PETSC_REAL PETSC_DOUBLE
404: #endif
406: #if defined(PETSC_USE_COMPLEX)
407: # define PETSC_SCALAR PETSC_COMPLEX
408: #else
409: # define PETSC_SCALAR PETSC_REAL
410: #endif
412: #define PETSC_FORTRANADDR PETSC_LONG
414: /*S
415: PetscToken - 'Token' used for managing tokenizing strings
417: Level: intermediate
419: .seealso: PetscTokenCreate(), PetscTokenFind(), PetscTokenDestroy()
420: S*/
421: typedef struct _p_PetscToken* PetscToken;
423: /*S
424: PetscObject - any PETSc object, PetscViewer, Mat, Vec, KSP etc
426: Level: beginner
428: Note:
429: This is the base class from which all PETSc objects are derived from.
431: .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName(), PetscObjectReference(), PetscObjectDereference()
432: S*/
433: typedef struct _p_PetscObject* PetscObject;
435: /*MC
436: PetscObjectId - unique integer Id for a PetscObject
438: Level: developer
440: Notes:
441: Unlike pointer values, object ids are never reused.
443: .seealso: PetscObjectState, PetscObjectGetId()
444: M*/
445: typedef PetscInt64 PetscObjectId;
447: /*MC
448: PetscObjectState - integer state for a PetscObject
450: Level: developer
452: Notes:
453: Object state is always-increasing and (for objects that track state) can be used to determine if an object has
454: changed since the last time you interacted with it. It is 64-bit so that it will not overflow for a very long time.
456: .seealso: PetscObjectId, PetscObjectStateGet(), PetscObjectStateIncrease(), PetscObjectStateSet()
457: M*/
458: typedef PetscInt64 PetscObjectState;
460: /*S
461: PetscFunctionList - Linked list of functions, possibly stored in dynamic libraries, accessed
462: by string name
464: Level: advanced
466: .seealso: PetscFunctionListAdd(), PetscFunctionListDestroy()
467: S*/
468: typedef struct _n_PetscFunctionList *PetscFunctionList;
470: /*E
471: PetscFileMode - Access mode for a file.
473: Level: beginner
475: $ FILE_MODE_UNDEFINED - initial invalid value
476: $ FILE_MODE_READ - open a file at its beginning for reading
477: $ FILE_MODE_WRITE - open a file at its beginning for writing (will create if the file does not exist)
478: $ FILE_MODE_APPEND - open a file at end for writing
479: $ FILE_MODE_UPDATE - open a file for updating, meaning for reading and writing
480: $ FILE_MODE_APPEND_UPDATE - open a file for updating, meaning for reading and writing, at the end
482: .seealso: PetscViewerFileSetMode()
483: E*/
484: typedef enum {FILE_MODE_UNDEFINED=-1, FILE_MODE_READ=0, FILE_MODE_WRITE, FILE_MODE_APPEND, FILE_MODE_UPDATE, FILE_MODE_APPEND_UPDATE} PetscFileMode;
486: typedef void* PetscDLHandle;
487: typedef enum {PETSC_DL_DECIDE=0,PETSC_DL_NOW=1,PETSC_DL_LOCAL=2} PetscDLMode;
489: /*S
490: PetscObjectList - Linked list of PETSc objects, each accessible by string name
492: Level: developer
494: Notes:
495: Used by PetscObjectCompose() and PetscObjectQuery()
497: .seealso: PetscObjectListAdd(), PetscObjectListDestroy(), PetscObjectListFind(), PetscObjectCompose(), PetscObjectQuery(), PetscFunctionList
498: S*/
499: typedef struct _n_PetscObjectList *PetscObjectList;
501: /*S
502: PetscDLLibrary - Linked list of dynamics libraries to search for functions
504: Level: advanced
506: .seealso: PetscDLLibraryOpen()
507: S*/
508: typedef struct _n_PetscDLLibrary *PetscDLLibrary;
510: /*S
511: PetscContainer - Simple PETSc object that contains a pointer to any required data
513: Level: advanced
515: .seealso: PetscObject, PetscContainerCreate()
516: S*/
517: typedef struct _p_PetscContainer* PetscContainer;
519: /*S
520: PetscRandom - Abstract PETSc object that manages generating random numbers
522: Level: intermediate
524: .seealso: PetscRandomCreate(), PetscRandomGetValue(), PetscRandomType
525: S*/
526: typedef struct _p_PetscRandom* PetscRandom;
528: /*
529: In binary files variables are stored using the following lengths,
530: regardless of how they are stored in memory on any one particular
531: machine. Use these rather then sizeof() in computing sizes for
532: PetscBinarySeek().
533: */
534: #define PETSC_BINARY_INT_SIZE (32/8)
535: #define PETSC_BINARY_FLOAT_SIZE (32/8)
536: #define PETSC_BINARY_CHAR_SIZE (8/8)
537: #define PETSC_BINARY_SHORT_SIZE (16/8)
538: #define PETSC_BINARY_DOUBLE_SIZE (64/8)
539: #define PETSC_BINARY_SCALAR_SIZE sizeof(PetscScalar)
541: /*E
542: PetscBinarySeekType - argument to PetscBinarySeek()
544: Level: advanced
546: .seealso: PetscBinarySeek(), PetscBinarySynchronizedSeek()
547: E*/
548: typedef enum {PETSC_BINARY_SEEK_SET = 0,PETSC_BINARY_SEEK_CUR = 1,PETSC_BINARY_SEEK_END = 2} PetscBinarySeekType;
550: /*E
551: PetscBuildTwoSidedType - algorithm for setting up two-sided communication
553: $ PETSC_BUILDTWOSIDED_ALLREDUCE - classical algorithm using an MPI_Allreduce with
554: $ a buffer of length equal to the communicator size. Not memory-scalable due to
555: $ the large reduction size. Requires only MPI-1.
556: $ PETSC_BUILDTWOSIDED_IBARRIER - nonblocking algorithm based on MPI_Issend and MPI_Ibarrier.
557: $ Proved communication-optimal in Hoefler, Siebert, and Lumsdaine (2010). Requires MPI-3.
558: $ PETSC_BUILDTWOSIDED_REDSCATTER - similar to above, but use more optimized function
559: $ that only communicates the part of the reduction that is necessary. Requires MPI-2.
561: Level: developer
563: .seealso: PetscCommBuildTwoSided(), PetscCommBuildTwoSidedSetType(), PetscCommBuildTwoSidedGetType()
564: E*/
565: typedef enum {
566: PETSC_BUILDTWOSIDED_NOTSET = -1,
567: PETSC_BUILDTWOSIDED_ALLREDUCE = 0,
568: PETSC_BUILDTWOSIDED_IBARRIER = 1,
569: PETSC_BUILDTWOSIDED_REDSCATTER = 2
570: /* Updates here must be accompanied by updates in finclude/petscsys.h and the string array in mpits.c */
571: } PetscBuildTwoSidedType;
573: /* NOTE: If you change this, you must also change the values in src/vec/f90-mod/petscvec.h */
574: /*E
575: InsertMode - Whether entries are inserted or added into vectors or matrices
577: Level: beginner
579: .seealso: VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(),
580: VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(),
581: MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd()
582: E*/
583: typedef enum {NOT_SET_VALUES, INSERT_VALUES, ADD_VALUES, MAX_VALUES, MIN_VALUES, INSERT_ALL_VALUES, ADD_ALL_VALUES, INSERT_BC_VALUES, ADD_BC_VALUES} InsertMode;
585: /*MC
586: INSERT_VALUES - Put a value into a vector or matrix, overwrites any previous value
588: Level: beginner
590: .seealso: InsertMode, VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(),
591: VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), ADD_VALUES,
592: MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd(), MAX_VALUES
594: M*/
596: /*MC
597: ADD_VALUES - Adds a value into a vector or matrix, if there previously was no value, just puts the
598: value into that location
600: Level: beginner
602: .seealso: InsertMode, VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(),
603: VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), INSERT_VALUES,
604: MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd(), MAX_VALUES
606: M*/
608: /*MC
609: MAX_VALUES - Puts the maximum of the scattered/gathered value and the current value into each location
611: Level: beginner
613: .seealso: InsertMode, VecScatterBegin(), VecScatterEnd(), ADD_VALUES, INSERT_VALUES
615: M*/
617: /*MC
618: MIN_VALUES - Puts the minimal of the scattered/gathered value and the current value into each location
620: Level: beginner
622: .seealso: InsertMode, VecScatterBegin(), VecScatterEnd(), ADD_VALUES, INSERT_VALUES
624: M*/
626: /*S
627: PetscSubcomm - A decomposition of an MPI communicator into subcommunicators
629: Notes:
630: After a call to PetscSubcommSetType(), PetscSubcommSetTypeGeneral(), or PetscSubcommSetFromOptions() one may call
631: $ PetscSubcommChild() returns the associated subcommunicator on this process
632: $ PetscSubcommContiguousParent() returns a parent communitor but with all child of the same subcommunicator having contiguous rank
634: Sample Usage:
635: PetscSubcommCreate()
636: PetscSubcommSetNumber()
637: PetscSubcommSetType(PETSC_SUBCOMM_INTERLACED);
638: ccomm = PetscSubcommChild()
639: PetscSubcommDestroy()
641: Level: advanced
643: Notes:
644: $ PETSC_SUBCOMM_GENERAL - similar to MPI_Comm_split() each process sets the new communicator (color) they will belong to and the order within that communicator
645: $ PETSC_SUBCOMM_CONTIGUOUS - each new communicator contains a set of process with contiguous ranks in the original MPI communicator
646: $ PETSC_SUBCOMM_INTERLACED - each new communictor contains a set of processes equally far apart in rank from the others in that new communicator
648: Example: Consider a communicator with six processes split into 3 subcommunicators.
649: $ PETSC_SUBCOMM_CONTIGUOUS - the first communicator contains rank 0,1 the second rank 2,3 and the third rank 4,5 in the original ordering of the original communicator
650: $ PETSC_SUBCOMM_INTERLACED - the first communicator contains rank 0,3, the second 1,4 and the third 2,5
652: Developer Notes:
653: This is used in objects such as PCREDUNDANT to manage the subcommunicators on which the redundant computations
654: are performed.
656: .seealso: PetscSubcommCreate(), PetscSubcommSetNumber(), PetscSubcommSetType(), PetscSubcommView(), PetscSubcommSetFromOptions()
658: S*/
659: typedef struct _n_PetscSubcomm* PetscSubcomm;
660: typedef enum {PETSC_SUBCOMM_GENERAL=0,PETSC_SUBCOMM_CONTIGUOUS=1,PETSC_SUBCOMM_INTERLACED=2} PetscSubcommType;
662: /*S
663: PetscHeap - A simple class for managing heaps
665: Level: intermediate
667: .seealso: PetscHeapCreate(), PetscHeapAdd(), PetscHeapPop(), PetscHeapPeek(), PetscHeapStash(), PetscHeapUnstash(), PetscHeapView(), PetscHeapDestroy()
668: S*/
669: typedef struct _PetscHeap *PetscHeap;
671: typedef struct _n_PetscShmComm* PetscShmComm;
672: typedef struct _n_PetscOmpCtrl* PetscOmpCtrl;
674: /*S
675: PetscSegBuffer - a segmented extendable buffer
677: Level: developer
679: .seealso: PetscSegBufferCreate(), PetscSegBufferGet(), PetscSegBufferExtract(), PetscSegBufferDestroy()
680: S*/
681: typedef struct _n_PetscSegBuffer *PetscSegBuffer;
683: typedef struct _n_PetscOptionsHelpPrinted *PetscOptionsHelpPrinted;
684: #endif