Actual source code: petscsystypes.h

petsc-master 2019-11-22
Report Typos and Errors
  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: /*E
144:     PetscBool  - Logical variable. Actually an int in C and a logical in Fortran.

146:    Level: beginner

148:    Developer Note:
149:    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
150:       boolean values. It is not easy to have a simple macro that that will work properly in all circumstances with all three mechanisms.

152: .seealso: PETSC_TRUE, PETSC_FALSE, PetscNot()
153: E*/
154: typedef enum { PETSC_FALSE,PETSC_TRUE } PetscBool;

156: /*MC
157:    PetscReal - PETSc type that represents a real number version of PetscScalar


160:    Notes:
161:    For MPI calls that require datatypes, use MPIU_REAL as the datatype for PetscScalar and MPIU_SUM, MPIU_MAX, etc. for operations.
162:           They will automatically work correctly regardless of the size of PetscReal.

164:           See PetscScalar for details on how to ./configure the size of PetscReal.

166:    Level: beginner

168: .seealso: PetscScalar, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT
169: M*/

171: #if defined(PETSC_USE_REAL_SINGLE)
172:    typedef float PetscReal;
173: #elif defined(PETSC_USE_REAL_DOUBLE)
174:    typedef double PetscReal;
175: #elif defined(PETSC_USE_REAL___FLOAT128)
176: #  if defined(__cplusplus)
177:      extern "C" {
178: #  endif
179: #  include <quadmath.h>
180: #  if defined(__cplusplus)
181:      }
182: #  endif
183:    typedef __float128 PetscReal;
184: #elif defined(PETSC_USE_REAL___FP16)
185:    typedef __fp16 PetscReal;
186: #endif /* PETSC_USE_REAL_* */

188: /*MC
189:    PetscComplex - PETSc type that represents a complex number with precision matching that of PetscReal.

191:    Synopsis:
192:    #include <petscsys.h>
193:    PetscComplex number = 1. + 2.*PETSC_i;

195:    Notes:
196:    For MPI calls that require datatypes, use MPIU_COMPLEX as the datatype for PetscComplex and MPIU_SUM etc for operations.
197:           They will automatically work correctly regardless of the size of PetscComplex.

199:           See PetscScalar for details on how to ./configure the size of PetscReal

201:           Complex numbers are automatically available if PETSc was able to find a working complex implementation

203:    Level: beginner

205: .seealso: PetscReal, PetscScalar, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT, PETSC_i
206: M*/

208: #if defined(__cplusplus) && defined(PETSC_HAVE_CXX_COMPLEX) && !defined(PETSC_USE_REAL___FLOAT128)
209: #  if !defined(PETSC_SKIP_COMPLEX)
210:      /* C++ support of complex number */
211: #    define PETSC_HAVE_COMPLEX 1
212: #    if defined(PETSC_HAVE_CUDA) && __CUDACC_VER_MAJOR__ > 6
213:        /* complex headers in thrust only available in CUDA 7.0 and above */
214: #      define petsccomplexlib thrust
215: #      include <thrust/complex.h>
216: #    else
217: #      define petsccomplexlib std
218: #      include <complex>
219: #    endif
220: #    if defined(PETSC_USE_REAL_SINGLE)
221:        typedef petsccomplexlib::complex<float> PetscComplex;
222: #    elif defined(PETSC_USE_REAL_DOUBLE)
223:        typedef petsccomplexlib::complex<double> PetscComplex;
224: #    elif defined(PETSC_USE_REAL___FLOAT128)
225:        typedef petsccomplexlib::complex<__float128> PetscComplex; /* Notstandard and not expected to work, use __complex128 */
226: #    endif  /* PETSC_USE_REAL_ */
227: #  endif  /* ! PETSC_SKIP_COMPLEX */
228: #  if !defined(PETSC_SKIP_CXX_COMPLEX_FIX)
229: #    include <petsccxxcomplexfix.h>
230: #  endif /* ! PETSC_SKIP_CXX_COMPLEX_FIX */
231: #elif defined(PETSC_HAVE_C99_COMPLEX) && !defined(PETSC_USE_REAL___FP16)
232: #  if !defined(PETSC_SKIP_COMPLEX)
233: #    define PETSC_HAVE_COMPLEX 1
234: #    include <complex.h>
235: #    if defined(PETSC_USE_REAL_SINGLE) || defined(PETSC_USE_REAL___FP16)
236:        typedef float _Complex PetscComplex;
237: #    elif defined(PETSC_USE_REAL_DOUBLE)
238:        typedef double _Complex PetscComplex;
239: #    elif defined(PETSC_USE_REAL___FLOAT128)
240:        typedef __complex128 PetscComplex;
241: #    endif /* PETSC_USE_REAL_* */
242: #  endif /* !PETSC_SKIP_COMPLEX */
243: #elif (defined(PETSC_USE_COMPLEX) && !defined(PETSC_SKIP_COMPLEX))
244: #  error "PETSc was configured --with-scalar-type=complex, but a language-appropriate complex library is not available"
245: #endif /* !PETSC_SKIP_COMPLEX */

247: /*MC
248:    PetscScalar - PETSc type that represents either a double precision real number, a double precision
249:        complex number, a single precision real number, a __float128 real or complex or a __fp16 real - if the code is configured
250:        with --with-scalar-type=real,complex --with-precision=single,double,__float128,__fp16

252:    Notes:
253:    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.

255:    Level: beginner

257: .seealso: PetscReal, PetscComplex, PetscInt, MPIU_REAL, MPIU_SCALAR, MPIU_COMPLEX, MPIU_INT, PetscRealPart(), PetscImaginaryPart()
258: M*/

260: #if (defined(PETSC_USE_COMPLEX) && !defined(PETSC_SKIP_COMPLEX))
261:    typedef PetscComplex PetscScalar;
262: #else /* PETSC_USE_COMPLEX */
263:    typedef PetscReal PetscScalar;
264: #endif /* PETSC_USE_COMPLEX */

266: /*E
267:     PetscCopyMode  - Determines how an array or PetscObject passed to certain functions is copied or retained by the aggregate PetscObject

269:    Level: beginner

271:    For the array input:
272: $   PETSC_COPY_VALUES - the array values are copied into new space, the user is free to reuse or delete the passed in array
273: $   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
274: $                       delete the array. The array MUST have been obtained with PetscMalloc(). Hence this mode cannot be used in Fortran.
275: $   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
276: $                       the array but the user must delete the array after the object is destroyed.

278:    For the PetscObject input:
279: $   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.
280: $   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.)
281:    For either case above, the input PetscObject should be destroyed by the user when no longer needed (the aggregate object increases its reference count).
282: $   PETSC_USE_POINTER - invalid for PetscObject inputs.

284: E*/
285: typedef enum {PETSC_COPY_VALUES, PETSC_OWN_POINTER, PETSC_USE_POINTER} PetscCopyMode;

287: /*MC
288:     PETSC_FALSE - False value of PetscBool

290:     Level: beginner

292:     Note:
293:     Zero integer

295: .seealso: PetscBool, PETSC_TRUE
296: M*/

298: /*MC
299:     PETSC_TRUE - True value of PetscBool

301:     Level: beginner

303:     Note:
304:     Nonzero integer

306: .seealso: PetscBool, PETSC_FALSE
307: M*/

309: /*MC
310:     PetscLogDouble - Used for logging times

312:   Notes:
313:   Contains double precision numbers that are not used in the numerical computations, but rather in logging, timing etc.

315:   Level: developer

317: M*/
318: typedef double PetscLogDouble;

320: /*E
321:     PetscDataType - Used for handling different basic data types.

323:    Level: beginner

325:    Notes:
326:    Use of this should be avoided if one can directly use MPI_Datatype instead.

328:    PETSC_INT is the datatype for a PetscInt, regardless of whether it is 4 or 8 bytes.
329:    PETSC_REAL, PETSC_COMPLEX and PETSC_SCALAR are the datatypes for PetscReal, PetscComplex and PetscScalar, regardless of their sizes.

331:    Developer comment:
332:    It would be nice if we could always just use MPI Datatypes, why can we not?

334:    If you change any values in PetscDatatype make sure you update their usage in
335:    share/petsc/matlab/PetscBagRead.m

337:    TODO: Add PETSC_INT32 and remove use of improper PETSC_ENUM

339: .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(),
340:           PetscDataTypeGetSize()

342: E*/
343: typedef enum {PETSC_DATATYPE_UNKNOWN = 0,
344:               PETSC_DOUBLE = 1, PETSC_COMPLEX = 2, PETSC_LONG = 3, PETSC_SHORT = 4, PETSC_FLOAT = 5,
345:               PETSC_CHAR = 6, PETSC_BIT_LOGICAL = 7, PETSC_ENUM = 8, PETSC_BOOL = 9, PETSC___FLOAT128 = 10,
346:               PETSC_OBJECT = 11, PETSC_FUNCTION = 12, PETSC_STRING = 13, PETSC___FP16 = 14, PETSC_STRUCT = 15,
347:               PETSC_INT = 16, PETSC_INT64 = 17} PetscDataType;

349: #if defined(PETSC_USE_REAL_SINGLE)
350: #  define PETSC_REAL PETSC_FLOAT
351: #elif defined(PETSC_USE_REAL_DOUBLE)
352: #  define PETSC_REAL PETSC_DOUBLE
353: #elif defined(PETSC_USE_REAL___FLOAT128)
354: #  define PETSC_REAL PETSC___FLOAT128
355: #elif defined(PETSC_USE_REAL___FP16)
356: #  define PETSC_REAL PETSC___FP16
357: #else
358: #  define PETSC_REAL PETSC_DOUBLE
359: #endif

361: #if defined(PETSC_USE_COMPLEX)
362: #  define PETSC_SCALAR PETSC_COMPLEX
363: #else
364: #  define PETSC_SCALAR PETSC_REAL
365: #endif

367: #define PETSC_FORTRANADDR PETSC_LONG

369: /*S
370:     PetscToken - 'Token' used for managing tokenizing strings

372:   Level: intermediate

374: .seealso: PetscTokenCreate(), PetscTokenFind(), PetscTokenDestroy()
375: S*/
376: typedef struct _p_PetscToken* PetscToken;

378: /*S
379:      PetscObject - any PETSc object, PetscViewer, Mat, Vec, KSP etc

381:    Level: beginner

383:    Note:
384:    This is the base class from which all PETSc objects are derived from.

386: .seealso:  PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName(), PetscObjectReference(), PetscObjectDereference()
387: S*/
388: typedef struct _p_PetscObject* PetscObject;

390: /*MC
391:     PetscObjectId - unique integer Id for a PetscObject

393:     Level: developer

395:     Notes:
396:     Unlike pointer values, object ids are never reused.

398: .seealso: PetscObjectState, PetscObjectGetId()
399: M*/
400: #if defined(PETSC_USING_F90) && !defined(PETSC_USE_FORTRANKIND) /* compaq F90 */
401:    typedef int PetscObjectId;
402: #else
403:    typedef PetscInt64 PetscObjectId;
404: #endif

406: /*MC
407:     PetscObjectState - integer state for a PetscObject

409:     Level: developer

411:     Notes:
412:     Object state is always-increasing and (for objects that track state) can be used to determine if an object has
413:     changed since the last time you interacted with it.  It is 64-bit so that it will not overflow for a very long time.

415: .seealso: PetscObjectId, PetscObjectStateGet(), PetscObjectStateIncrease(), PetscObjectStateSet()
416: M*/
417: #if defined(PETSC_USING_F90) && !defined(PETSC_USE_FORTRANKIND) /* compaq F90 */
418:    typedef int PetscObjectState;
419: #else
420:    typedef PetscInt64 PetscObjectState;
421: #endif

423: /*S
424:      PetscFunctionList - Linked list of functions, possibly stored in dynamic libraries, accessed
425:       by string name

427:    Level: advanced

429: .seealso:  PetscFunctionListAdd(), PetscFunctionListDestroy(), PetscOpFlist
430: S*/
431: typedef struct _n_PetscFunctionList *PetscFunctionList;

433: /*E
434:   PetscFileMode - Access mode for a file.

436:   Level: beginner

438: $  FILE_MODE_READ - open a file at its beginning for reading
439: $  FILE_MODE_WRITE - open a file at its beginning for writing (will create if the file does not exist)
440: $  FILE_MODE_APPEND - open a file at end for writing
441: $  FILE_MODE_UPDATE - open a file for updating, meaning for reading and writing
442: $  FILE_MODE_APPEND_UPDATE - open a file for updating, meaning for reading and writing, at the end

444: .seealso: PetscViewerFileSetMode()
445: E*/
446: typedef enum {FILE_MODE_READ, FILE_MODE_WRITE, FILE_MODE_APPEND, FILE_MODE_UPDATE, FILE_MODE_APPEND_UPDATE} PetscFileMode;

448: typedef void* PetscDLHandle;
449: typedef enum {PETSC_DL_DECIDE=0,PETSC_DL_NOW=1,PETSC_DL_LOCAL=2} PetscDLMode;

451: /*S
452:      PetscObjectList - Linked list of PETSc objects, each accessable by string name

454:    Level: developer

456:    Notes:
457:    Used by PetscObjectCompose() and PetscObjectQuery()

459: .seealso:  PetscObjectListAdd(), PetscObjectListDestroy(), PetscObjectListFind(), PetscObjectCompose(), PetscObjectQuery(), PetscFunctionList
460: S*/
461: typedef struct _n_PetscObjectList *PetscObjectList;

463: /*S
464:      PetscDLLibrary - Linked list of dynamics libraries to search for functions

466:    Level: advanced

468: .seealso:  PetscDLLibraryOpen()
469: S*/
470: typedef struct _n_PetscDLLibrary *PetscDLLibrary;

472: /*S
473:      PetscContainer - Simple PETSc object that contains a pointer to any required data

475:    Level: advanced

477: .seealso:  PetscObject, PetscContainerCreate()
478: S*/
479: typedef struct _p_PetscContainer*  PetscContainer;

481: /*S
482:      PetscRandom - Abstract PETSc object that manages generating random numbers

484:    Level: intermediate

486: .seealso:  PetscRandomCreate(), PetscRandomGetValue(), PetscRandomType
487: S*/
488: typedef struct _p_PetscRandom*   PetscRandom;

490: /*
491:    In binary files variables are stored using the following lengths,
492:   regardless of how they are stored in memory on any one particular
493:   machine. Use these rather then sizeof() in computing sizes for
494:   PetscBinarySeek().
495: */
496: #define PETSC_BINARY_INT_SIZE    (32/8)
497: #define PETSC_BINARY_FLOAT_SIZE  (32/8)
498: #define PETSC_BINARY_CHAR_SIZE   (8/8)
499: #define PETSC_BINARY_SHORT_SIZE  (16/8)
500: #define PETSC_BINARY_DOUBLE_SIZE (64/8)
501: #define PETSC_BINARY_SCALAR_SIZE sizeof(PetscScalar)

503: /*E
504:   PetscBinarySeekType - argument to PetscBinarySeek()

506:   Level: advanced

508: .seealso: PetscBinarySeek(), PetscBinarySynchronizedSeek()
509: E*/
510: typedef enum {PETSC_BINARY_SEEK_SET = 0,PETSC_BINARY_SEEK_CUR = 1,PETSC_BINARY_SEEK_END = 2} PetscBinarySeekType;

512: /*E
513:     PetscBuildTwoSidedType - algorithm for setting up two-sided communication

515: $  PETSC_BUILDTWOSIDED_ALLREDUCE - classical algorithm using an MPI_Allreduce with
516: $      a buffer of length equal to the communicator size. Not memory-scalable due to
517: $      the large reduction size. Requires only MPI-1.
518: $  PETSC_BUILDTWOSIDED_IBARRIER - nonblocking algorithm based on MPI_Issend and MPI_Ibarrier.
519: $      Proved communication-optimal in Hoefler, Siebert, and Lumsdaine (2010). Requires MPI-3.
520: $  PETSC_BUILDTWOSIDED_REDSCATTER - similar to above, but use more optimized function
521: $      that only communicates the part of the reduction that is necessary.  Requires MPI-2.

523:    Level: developer

525: .seealso: PetscCommBuildTwoSided(), PetscCommBuildTwoSidedSetType(), PetscCommBuildTwoSidedGetType()
526: E*/
527: typedef enum {
528:   PETSC_BUILDTWOSIDED_NOTSET = -1,
529:   PETSC_BUILDTWOSIDED_ALLREDUCE = 0,
530:   PETSC_BUILDTWOSIDED_IBARRIER = 1,
531:   PETSC_BUILDTWOSIDED_REDSCATTER = 2
532:   /* Updates here must be accompanied by updates in finclude/petscsys.h and the string array in mpits.c */
533: } PetscBuildTwoSidedType;

535: /*E
536:   InsertMode - Whether entries are inserted or added into vectors or matrices

538:   Level: beginner

540: .seealso: VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(),
541:           VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(),
542:           MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd()
543: E*/
544:  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;

546: /*MC
547:     INSERT_VALUES - Put a value into a vector or matrix, overwrites any previous value

549:     Level: beginner

551: .seealso: InsertMode, VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(),
552:           VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), ADD_VALUES,
553:           MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd(), MAX_VALUES

555: M*/

557: /*MC
558:     ADD_VALUES - Adds a value into a vector or matrix, if there previously was no value, just puts the
559:                 value into that location

561:     Level: beginner

563: .seealso: InsertMode, VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(),
564:           VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), INSERT_VALUES,
565:           MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd(), MAX_VALUES

567: M*/

569: /*MC
570:     MAX_VALUES - Puts the maximum of the scattered/gathered value and the current value into each location

572:     Level: beginner

574: .seealso: InsertMode, VecScatterBegin(), VecScatterEnd(), ADD_VALUES, INSERT_VALUES

576: M*/

578: /*MC
579:     MIN_VALUES - Puts the minimal of the scattered/gathered value and the current value into each location

581:     Level: beginner

583: .seealso: InsertMode, VecScatterBegin(), VecScatterEnd(), ADD_VALUES, INSERT_VALUES

585: M*/


588: /*S
589:    PetscSubcomm - A decomposition of an MPI communicator into subcommunicators

591:    Notes:
592:    After a call to PetscSubcommSetType(), PetscSubcommSetTypeGeneral(), or PetscSubcommSetFromOptions() one may call
593: $     PetscSubcommChild() returns the associated subcommunicator on this process
594: $     PetscSubcommContiguousParent() returns a parent communitor but with all child of the same subcommunicator having contiguous rank

596:    Sample Usage:
597:        PetscSubcommCreate()
598:        PetscSubcommSetNumber()
599:        PetscSubcommSetType(PETSC_SUBCOMM_INTERLACED);
600:        ccomm = PetscSubcommChild()
601:        PetscSubcommDestroy()

603:    Level: advanced

605:    Notes:
606: $   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
607: $   PETSC_SUBCOMM_CONTIGUOUS - each new communicator contains a set of process with contiguous ranks in the original MPI communicator
608: $   PETSC_SUBCOMM_INTERLACED - each new communictor contains a set of processes equally far apart in rank from the others in that new communicator

610:    Example: Consider a communicator with six processes split into 3 subcommunicators.
611: $     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
612: $     PETSC_SUBCOMM_INTERLACED - the first communicator contains rank 0,3, the second 1,4 and the third 2,5

614:    Developer Notes:
615:    This is used in objects such as PCREDUNDANT to manage the subcommunicators on which the redundant computations
616:       are performed.


619: .seealso: PetscSubcommCreate(), PetscSubcommSetNumber(), PetscSubcommSetType(), PetscSubcommView(), PetscSubcommSetFromOptions()

621: S*/
622: typedef struct _n_PetscSubcomm* PetscSubcomm;
623: typedef enum {PETSC_SUBCOMM_GENERAL=0,PETSC_SUBCOMM_CONTIGUOUS=1,PETSC_SUBCOMM_INTERLACED=2} PetscSubcommType;

625: /*S
626:      PetscHeap - A simple class for managing heaps

628:    Level: intermediate

630: .seealso:  PetscHeapCreate(), PetscHeapAdd(), PetscHeapPop(), PetscHeapPeek(), PetscHeapStash(), PetscHeapUnstash(), PetscHeapView(), PetscHeapDestroy()
631: S*/
632: typedef struct _PetscHeap *PetscHeap;

634: typedef struct _n_PetscShmComm* PetscShmComm;
635: typedef struct _n_PetscOmpCtrl* PetscOmpCtrl;

637: /*S
638:    PetscSegBuffer - a segmented extendable buffer

640:    Level: developer

642: .seealso: PetscSegBufferCreate(), PetscSegBufferGet(), PetscSegBufferExtract(), PetscSegBufferDestroy()
643: S*/
644: typedef struct _n_PetscSegBuffer *PetscSegBuffer;

646: typedef struct _n_PetscOptionsHelpPrinted *PetscOptionsHelpPrinted;

648: #endif