1d382aafbSBarry Smith /* 2d382aafbSBarry Smith This is the main PETSc include file (for C and C++). It is included by all 3d382aafbSBarry Smith other PETSc include files, so it almost never has to be specifically included. 4d382aafbSBarry Smith */ 56c7e564aSBarry Smith #if !defined(__PETSCSYS_H) 66c7e564aSBarry Smith #define __PETSCSYS_H 7d382aafbSBarry Smith /* ========================================================================== */ 8d382aafbSBarry Smith /* 9d382aafbSBarry Smith petscconf.h is contained in ${PETSC_ARCH}/include/petscconf.h it is 10d382aafbSBarry Smith found automatically by the compiler due to the -I${PETSC_DIR}/${PETSC_ARCH}/include 11d382aafbSBarry Smith in the conf/variables definition of PETSC_INCLUDE 12d382aafbSBarry Smith */ 13d382aafbSBarry Smith #include "petscconf.h" 14d382aafbSBarry Smith #include "petscfix.h" 15d382aafbSBarry Smith 16d382aafbSBarry Smith /* ========================================================================== */ 17d382aafbSBarry Smith /* 18d382aafbSBarry Smith This facilitates using C version of PETSc from C++ and 19d382aafbSBarry Smith C++ version from C. Use --with-c-support --with-clanguage=c++ with config/configure.py for the latter) 20d382aafbSBarry Smith */ 21d382aafbSBarry Smith #if defined(PETSC_CLANGUAGE_CXX) && !defined(PETSC_USE_EXTERN_CXX) && !defined(__cplusplus) 22d382aafbSBarry Smith #error "PETSc configured with --with-clanguage=c++ and NOT --with-c-support - it can be used only with a C++ compiler" 23d382aafbSBarry Smith #endif 24d382aafbSBarry Smith 25d382aafbSBarry Smith #if defined(PETSC_USE_EXTERN_CXX) && defined(__cplusplus) 26d382aafbSBarry Smith #define PETSC_EXTERN_CXX_BEGIN extern "C" { 27d382aafbSBarry Smith #define PETSC_EXTERN_CXX_END } 28d382aafbSBarry Smith #else 29d382aafbSBarry Smith #define PETSC_EXTERN_CXX_BEGIN 30d382aafbSBarry Smith #define PETSC_EXTERN_CXX_END 31d382aafbSBarry Smith #endif 32d382aafbSBarry Smith /* ========================================================================== */ 33d382aafbSBarry Smith /* 34d382aafbSBarry Smith Current PETSc version number and release date. Also listed in 35d382aafbSBarry Smith Web page 36d382aafbSBarry Smith src/docs/tex/manual/intro.tex, 37d382aafbSBarry Smith src/docs/tex/manual/manual.tex. 38d382aafbSBarry Smith src/docs/website/index.html. 39d382aafbSBarry Smith */ 40d382aafbSBarry Smith #include "petscversion.h" 41d382aafbSBarry Smith #define PETSC_AUTHOR_INFO "\ 42d382aafbSBarry Smith The PETSc Team\n\ 43d382aafbSBarry Smith petsc-maint@mcs.anl.gov\n\ 44d382aafbSBarry Smith http://www.mcs.anl.gov/petsc/\n" 45d382aafbSBarry Smith #if (PETSC_VERSION_RELEASE == 1) 46d382aafbSBarry Smith #define PetscGetVersion(version,len) (PetscSNPrintf(version,len,"Petsc Release Version %d.%d.%d, Patch %d, ", \ 47d382aafbSBarry Smith PETSC_VERSION_MAJOR,PETSC_VERSION_MINOR, PETSC_VERSION_SUBMINOR, \ 48d382aafbSBarry Smith PETSC_VERSION_PATCH),PetscStrcat(version,PETSC_VERSION_PATCH_DATE)) 49d382aafbSBarry Smith #else 50d382aafbSBarry Smith #define PetscGetVersion(version,len) (PetscSNPrintf(version,len,"Petsc Development"), \ 51d382aafbSBarry Smith PetscStrcat(version," HG revision: "),PetscStrcat(version,PETSC_VERSION_HG), \ 52d382aafbSBarry Smith PetscStrcat(version," HG Date: "),PetscStrcat(version,PETSC_VERSION_DATE_HG)) 53d382aafbSBarry Smith #endif 54d382aafbSBarry Smith 55d382aafbSBarry Smith /*MC 56d382aafbSBarry Smith PetscGetVersion - Gets the PETSc version information in a string. 57d382aafbSBarry Smith 58d382aafbSBarry Smith Input Parameter: 59d382aafbSBarry Smith . len - length of the string 60d382aafbSBarry Smith 61d382aafbSBarry Smith Output Parameter: 62d382aafbSBarry Smith . version - version string 63d382aafbSBarry Smith 64d382aafbSBarry Smith Level: developer 65d382aafbSBarry Smith 66d382aafbSBarry Smith Usage: 67d382aafbSBarry Smith char version[256]; 68d382aafbSBarry Smith ierr = PetscGetVersion(version,256);CHKERRQ(ierr) 69d382aafbSBarry Smith 70d382aafbSBarry Smith Fortran Note: 71d382aafbSBarry Smith This routine is not supported in Fortran. 72d382aafbSBarry Smith 73d382aafbSBarry Smith .seealso: PetscGetProgramName() 74d382aafbSBarry Smith 75d382aafbSBarry Smith M*/ 76d382aafbSBarry Smith 77d382aafbSBarry Smith /* ========================================================================== */ 78d382aafbSBarry Smith 79d382aafbSBarry Smith /* 80d382aafbSBarry Smith Currently cannot check formatting for PETSc print statements because we have our 81d382aafbSBarry Smith own format %D and %G 82d382aafbSBarry Smith */ 83d382aafbSBarry Smith #undef PETSC_PRINTF_FORMAT_CHECK 84d382aafbSBarry Smith #define PETSC_PRINTF_FORMAT_CHECK(a,b) 85d382aafbSBarry Smith #undef PETSC_FPRINTF_FORMAT_CHECK 86d382aafbSBarry Smith #define PETSC_FPRINTF_FORMAT_CHECK(a,b) 87d382aafbSBarry Smith 88d382aafbSBarry Smith /* 89d382aafbSBarry Smith Fixes for config/configure.py time choices which impact our interface. Currently only 90d382aafbSBarry Smith calling conventions and extra compiler checking falls under this category. 91d382aafbSBarry Smith */ 92d382aafbSBarry Smith #if !defined(PETSC_STDCALL) 93d382aafbSBarry Smith #define PETSC_STDCALL 94d382aafbSBarry Smith #endif 95d382aafbSBarry Smith #if !defined(PETSC_TEMPLATE) 96d382aafbSBarry Smith #define PETSC_TEMPLATE 97d382aafbSBarry Smith #endif 98d382aafbSBarry Smith #if !defined(PETSC_HAVE_DLL_EXPORT) 99d382aafbSBarry Smith #define PETSC_DLL_EXPORT 100d382aafbSBarry Smith #define PETSC_DLL_IMPORT 101d382aafbSBarry Smith #endif 102d382aafbSBarry Smith #if !defined(PETSC_DLLEXPORT) 103d382aafbSBarry Smith #define PETSC_DLLEXPORT 104d382aafbSBarry Smith #endif 105d382aafbSBarry Smith #if !defined(PETSCVEC_DLLEXPORT) 106d382aafbSBarry Smith #define PETSCVEC_DLLEXPORT 107d382aafbSBarry Smith #endif 108d382aafbSBarry Smith #if !defined(PETSCMAT_DLLEXPORT) 109d382aafbSBarry Smith #define PETSCMAT_DLLEXPORT 110d382aafbSBarry Smith #endif 111d382aafbSBarry Smith #if !defined(PETSCDM_DLLEXPORT) 112d382aafbSBarry Smith #define PETSCDM_DLLEXPORT 113d382aafbSBarry Smith #endif 114d382aafbSBarry Smith #if !defined(PETSCKSP_DLLEXPORT) 115d382aafbSBarry Smith #define PETSCKSP_DLLEXPORT 116d382aafbSBarry Smith #endif 117d382aafbSBarry Smith #if !defined(PETSCSNES_DLLEXPORT) 118d382aafbSBarry Smith #define PETSCSNES_DLLEXPORT 119d382aafbSBarry Smith #endif 120d382aafbSBarry Smith #if !defined(PETSCTS_DLLEXPORT) 121d382aafbSBarry Smith #define PETSCTS_DLLEXPORT 122d382aafbSBarry Smith #endif 123d382aafbSBarry Smith #if !defined(PETSCFORTRAN_DLLEXPORT) 124d382aafbSBarry Smith #define PETSCFORTRAN_DLLEXPORT 125d382aafbSBarry Smith #endif 126d382aafbSBarry Smith /* ========================================================================== */ 127d382aafbSBarry Smith 128d382aafbSBarry Smith /* 129d382aafbSBarry Smith Defines the interface to MPI allowing the use of all MPI functions. 130d382aafbSBarry Smith 131d382aafbSBarry Smith PETSc does not use the C++ binding of MPI at ALL. The following flag 132d382aafbSBarry Smith makes sure the C++ bindings are not included. The C++ bindings REQUIRE 133d382aafbSBarry Smith putting mpi.h before ANY C++ include files, we cannot control this 134d382aafbSBarry Smith with all PETSc users. Users who want to use the MPI C++ bindings can include 135d382aafbSBarry Smith mpicxx.h directly in their code 136d382aafbSBarry Smith */ 137d382aafbSBarry Smith #define MPICH_SKIP_MPICXX 1 138d382aafbSBarry Smith #define OMPI_SKIP_MPICXX 1 139d382aafbSBarry Smith #include "mpi.h" 14065013866SBarry Smith 141d382aafbSBarry Smith /* 142d382aafbSBarry Smith Yuck, we need to put stdio.h AFTER mpi.h for MPICH2 with C++ compiler 143d382aafbSBarry Smith see the top of mpicxx.h in the MPICH2 distribution. 144d382aafbSBarry Smith 145d382aafbSBarry Smith The MPI STANDARD HAS TO BE CHANGED to prevent this nonsense. 146d382aafbSBarry Smith */ 147d382aafbSBarry Smith #include <stdio.h> 148d382aafbSBarry Smith 149d382aafbSBarry Smith /* MSMPI on 32bit windows requires this yukky hack - that breaks MPI standard compliance */ 150d382aafbSBarry Smith #if !defined(MPIAPI) 151d382aafbSBarry Smith #define MPIAPI 152d382aafbSBarry Smith #endif 153d382aafbSBarry Smith 154d382aafbSBarry Smith /*MC 155d382aafbSBarry Smith PetscErrorCode - datatype used for return error code from all PETSc functions 156d382aafbSBarry Smith 157d382aafbSBarry Smith Level: beginner 158d382aafbSBarry Smith 159d382aafbSBarry Smith .seealso: CHKERRQ, SETERRQ 160d382aafbSBarry Smith M*/ 161d382aafbSBarry Smith typedef int PetscErrorCode; 162d382aafbSBarry Smith 163d382aafbSBarry Smith /*MC 164d382aafbSBarry Smith 165d382aafbSBarry Smith PetscCookie - A unique id used to identify each PETSc object. 166d382aafbSBarry Smith (internal integer in the data structure used for error 167d382aafbSBarry Smith checking). These are all defined by an offset from the lowest 168d382aafbSBarry Smith one, PETSC_SMALLEST_COOKIE. 169d382aafbSBarry Smith 170d382aafbSBarry Smith Level: advanced 171d382aafbSBarry Smith 172d382aafbSBarry Smith .seealso: PetscCookieRegister(), PetscLogEventRegister(), PetscHeaderCreate() 173d382aafbSBarry Smith M*/ 174d382aafbSBarry Smith typedef int PetscCookie; 175d382aafbSBarry Smith 176d382aafbSBarry Smith /*MC 177d382aafbSBarry Smith PetscLogEvent - id used to identify PETSc or user events - primarily for logging 178d382aafbSBarry Smith 179d382aafbSBarry Smith Level: intermediate 180d382aafbSBarry Smith 181d382aafbSBarry Smith .seealso: PetscLogEventRegister(), PetscLogEventBegin(), PetscLogEventEnd(), PetscLogStage 182d382aafbSBarry Smith M*/ 183d382aafbSBarry Smith typedef int PetscLogEvent; 184d382aafbSBarry Smith 185d382aafbSBarry Smith /*MC 186d382aafbSBarry Smith PetscLogStage - id used to identify user stages of runs - for logging 187d382aafbSBarry Smith 188d382aafbSBarry Smith Level: intermediate 189d382aafbSBarry Smith 190d382aafbSBarry Smith .seealso: PetscLogStageRegister(), PetscLogStageBegin(), PetscLogStageEnd(), PetscLogEvent 191d382aafbSBarry Smith M*/ 192d382aafbSBarry Smith typedef int PetscLogStage; 193d382aafbSBarry Smith 194d382aafbSBarry Smith /*MC 195d382aafbSBarry Smith PetscBLASInt - datatype used to represent 'int' parameters to BLAS/LAPACK functions. 196d382aafbSBarry Smith 197d382aafbSBarry Smith Level: intermediate 198d382aafbSBarry Smith 199d382aafbSBarry Smith Notes: usually this is the same as PetscInt, but if PETSc was built with --with-64-bit-indices but 200d382aafbSBarry Smith standard C/Fortran integers are 32 bit then this is NOT the same as PetscInt 201d382aafbSBarry Smith 202d382aafbSBarry Smith .seealso: PetscMPIInt, PetscInt 203d382aafbSBarry Smith 204d382aafbSBarry Smith M*/ 205d382aafbSBarry Smith typedef int PetscBLASInt; 206d382aafbSBarry Smith 207d382aafbSBarry Smith /*MC 208d382aafbSBarry Smith PetscMPIInt - datatype used to represent 'int' parameters to MPI functions. 209d382aafbSBarry Smith 210d382aafbSBarry Smith Level: intermediate 211d382aafbSBarry Smith 212d382aafbSBarry Smith Notes: usually this is the same as PetscInt, but if PETSc was built with --with-64-bit-indices but 213d382aafbSBarry Smith standard C/Fortran integers are 32 bit then this is NOT the same as PetscInt 214d382aafbSBarry Smith 215d382aafbSBarry Smith PetscBLASIntCheck(a) checks if the given PetscInt a will fit in a PetscBLASInt, if not it generates a 216d382aafbSBarry Smith PETSC_ERR_ARG_OUTOFRANGE. 217d382aafbSBarry Smith 218d382aafbSBarry Smith PetscBLASInt b = PetscBLASIntCast(a) checks if the given PetscInt a will fit in a PetscBLASInt, if not it 219d382aafbSBarry Smith generates a PETSC_ERR_ARG_OUTOFRANGE 220d382aafbSBarry Smith 221d382aafbSBarry Smith .seealso: PetscBLASInt, PetscInt 222d382aafbSBarry Smith 223d382aafbSBarry Smith M*/ 224d382aafbSBarry Smith typedef int PetscMPIInt; 225d382aafbSBarry Smith 226d382aafbSBarry Smith /*MC 227d382aafbSBarry Smith PetscEnum - datatype used to pass enum types within PETSc functions. 228d382aafbSBarry Smith 229d382aafbSBarry Smith Level: intermediate 230d382aafbSBarry Smith 231d382aafbSBarry Smith PetscMPIIntCheck(a) checks if the given PetscInt a will fit in a PetscMPIInt, if not it generates a 232d382aafbSBarry Smith PETSC_ERR_ARG_OUTOFRANGE. 233d382aafbSBarry Smith 234d382aafbSBarry Smith PetscMPIInt b = PetscMPIIntCast(a) checks if the given PetscInt a will fit in a PetscMPIInt, if not it 235d382aafbSBarry Smith generates a PETSC_ERR_ARG_OUTOFRANGE 236d382aafbSBarry Smith 237d382aafbSBarry Smith .seealso: PetscOptionsGetEnum(), PetscOptionsEnum(), PetscBagRegisterEnum() 238d382aafbSBarry Smith M*/ 239d382aafbSBarry Smith typedef enum { ENUM_DUMMY } PetscEnum; 240d382aafbSBarry Smith 241d382aafbSBarry Smith /*MC 242d382aafbSBarry Smith PetscInt - PETSc type that represents integer - used primarily to 243d382aafbSBarry Smith represent size of objects. Its size can be configured with the option 244d382aafbSBarry Smith --with-64-bit-indices - to be either 32bit or 64bit [default 32 bit ints] 245d382aafbSBarry Smith 246d382aafbSBarry Smith Level: intermediate 247d382aafbSBarry Smith 248d382aafbSBarry Smith 249d382aafbSBarry Smith .seealso: PetscScalar, PetscBLASInt, PetscMPIInt 250d382aafbSBarry Smith M*/ 251d382aafbSBarry Smith #if defined(PETSC_USE_64BIT_INDICES) 252d382aafbSBarry Smith typedef long long PetscInt; 253d382aafbSBarry Smith #define MPIU_INT MPI_LONG_LONG_INT 254d382aafbSBarry Smith #else 255d382aafbSBarry Smith typedef int PetscInt; 256d382aafbSBarry Smith #define MPIU_INT MPI_INT 257d382aafbSBarry Smith #endif 258d382aafbSBarry Smith 259d382aafbSBarry Smith /* add in MPIU type for size_t */ 260d382aafbSBarry Smith #if (PETSC_SIZEOF_SIZE_T) == (PETSC_SIZEOF_INT) 261d382aafbSBarry Smith #define MPIU_SIZE_T MPI_INT 262d382aafbSBarry Smith #elif (PETSC_SIZEOF_SIZE_T) == (PETSC_SIZEOF_LONG) 263d382aafbSBarry Smith #define MPIU_SIZE_T MPI_LONG 264d382aafbSBarry Smith #elif (PETSC_SIZEOF_SIZE_T) == (PETSC_SIZEOF_LONG_LONG) 265d382aafbSBarry Smith #define MPIU_SIZE_T MPI_LONG_LONG_INT 266d382aafbSBarry Smith #else 267d382aafbSBarry Smith #error "Unknown size for size_t! Send us a bugreport at petsc-maint@mcs.anl.gov" 268d382aafbSBarry Smith #endif 269d382aafbSBarry Smith 270d382aafbSBarry Smith 271d382aafbSBarry Smith /* 272d382aafbSBarry Smith You can use PETSC_STDOUT as a replacement of stdout. You can also change 273d382aafbSBarry Smith the value of PETSC_STDOUT to redirect all standard output elsewhere 274d382aafbSBarry Smith */ 275d382aafbSBarry Smith 276d382aafbSBarry Smith extern FILE* PETSC_STDOUT; 277d382aafbSBarry Smith 278d382aafbSBarry Smith /* 279d382aafbSBarry Smith You can use PETSC_STDERR as a replacement of stderr. You can also change 280d382aafbSBarry Smith the value of PETSC_STDERR to redirect all standard error elsewhere 281d382aafbSBarry Smith */ 282d382aafbSBarry Smith extern FILE* PETSC_STDERR; 283d382aafbSBarry Smith 284d382aafbSBarry Smith /* 285d382aafbSBarry Smith PETSC_ZOPEFD is used to send data to the PETSc webpage. It can be used 286d382aafbSBarry Smith in conjunction with PETSC_STDOUT, or by itself. 287d382aafbSBarry Smith */ 288d382aafbSBarry Smith extern FILE* PETSC_ZOPEFD; 289d382aafbSBarry Smith 290d382aafbSBarry Smith #if !defined(PETSC_USE_EXTERN_CXX) && defined(__cplusplus) 291d382aafbSBarry Smith /*MC 292d382aafbSBarry Smith PetscPolymorphicSubroutine - allows defining a C++ polymorphic version of 293d382aafbSBarry Smith a PETSc function that remove certain optional arguments for a simplier user interface 294d382aafbSBarry Smith 295d382aafbSBarry Smith Not collective 296d382aafbSBarry Smith 297d382aafbSBarry Smith Synopsis: 298d382aafbSBarry Smith PetscPolymorphicSubroutine(Functionname,(arguments of C++ function),(arguments of C function)) 299d382aafbSBarry Smith 300d382aafbSBarry Smith Level: developer 301d382aafbSBarry Smith 302d382aafbSBarry Smith Example: 303d382aafbSBarry Smith PetscPolymorphicSubroutine(VecNorm,(Vec x,PetscReal *r),(x,NORM_2,r)) generates the new routine 304d382aafbSBarry Smith PetscErrorCode VecNorm(Vec x,PetscReal *r) = VecNorm(x,NORM_2,r) 305d382aafbSBarry Smith 306d382aafbSBarry Smith .seealso: PetscPolymorphicFunction() 307d382aafbSBarry Smith 308d382aafbSBarry Smith M*/ 309d382aafbSBarry Smith #define PetscPolymorphicSubroutine(A,B,C) PETSC_STATIC_INLINE PetscErrorCode A B {return A C;} 310d382aafbSBarry Smith 311d382aafbSBarry Smith /*MC 312d382aafbSBarry Smith PetscPolymorphicScalar - allows defining a C++ polymorphic version of 313d382aafbSBarry Smith a PETSc function that replaces a PetscScalar * argument with a PetscScalar argument 314d382aafbSBarry Smith 315d382aafbSBarry Smith Not collective 316d382aafbSBarry Smith 317d382aafbSBarry Smith Synopsis: 318d382aafbSBarry Smith PetscPolymorphicScalar(Functionname,(arguments of C++ function),(arguments of C function)) 319d382aafbSBarry Smith 320d382aafbSBarry Smith Level: developer 321d382aafbSBarry Smith 322d382aafbSBarry Smith Example: 323d382aafbSBarry Smith PetscPolymorphicScalar(VecAXPY,(PetscScalar _val,Vec x,Vec y),(&_Val,x,y)) generates the new routine 324d382aafbSBarry Smith PetscErrorCode VecAXPY(PetscScalar _val,Vec x,Vec y) = {PetscScalar _Val = _val; return VecAXPY(&_Val,x,y);} 325d382aafbSBarry Smith 326d382aafbSBarry Smith .seealso: PetscPolymorphicFunction(),PetscPolymorphicSubroutine() 327d382aafbSBarry Smith 328d382aafbSBarry Smith M*/ 329d382aafbSBarry Smith #define PetscPolymorphicScalar(A,B,C) PETSC_STATIC_INLINE PetscErrorCode A B {PetscScalar _Val = _val; return A C;} 330d382aafbSBarry Smith 331d382aafbSBarry Smith /*MC 332d382aafbSBarry Smith PetscPolymorphicFunction - allows defining a C++ polymorphic version of 333d382aafbSBarry Smith a PETSc function that remove certain optional arguments for a simplier user interface 334d382aafbSBarry Smith and returns the computed value (istead of an error code) 335d382aafbSBarry Smith 336d382aafbSBarry Smith Not collective 337d382aafbSBarry Smith 338d382aafbSBarry Smith Synopsis: 339d382aafbSBarry Smith PetscPolymorphicFunction(Functionname,(arguments of C++ function),(arguments of C function),return type,return variable name) 340d382aafbSBarry Smith 341d382aafbSBarry Smith Level: developer 342d382aafbSBarry Smith 343d382aafbSBarry Smith Example: 344d382aafbSBarry Smith PetscPolymorphicFunction(VecNorm,(Vec x,NormType t),(x,t,&r),PetscReal,r) generates the new routine 345d382aafbSBarry Smith PetscReal VecNorm(Vec x,NormType t) = {PetscReal r; VecNorm(x,t,&r); return r;} 346d382aafbSBarry Smith 347d382aafbSBarry Smith .seealso: PetscPolymorphicSubroutine() 348d382aafbSBarry Smith 349d382aafbSBarry Smith M*/ 350d382aafbSBarry Smith #define PetscPolymorphicFunction(A,B,C,D,E) PETSC_STATIC_INLINE D A B {D E; A C;return E;} 351d382aafbSBarry Smith 352d382aafbSBarry Smith #else 353d382aafbSBarry Smith #define PetscPolymorphicSubroutine(A,B,C) 354d382aafbSBarry Smith #define PetscPolymorphicScalar(A,B,C) 355d382aafbSBarry Smith #define PetscPolymorphicFunction(A,B,C,D,E) 356d382aafbSBarry Smith #endif 357d382aafbSBarry Smith 358d382aafbSBarry Smith /*MC 359d382aafbSBarry Smith PetscUnlikely - hints the compiler that the given condition is usually FALSE 360d382aafbSBarry Smith 361d382aafbSBarry Smith Not Collective 362d382aafbSBarry Smith 363d382aafbSBarry Smith Synopsis: 364d382aafbSBarry Smith PetscTruth PetscUnlikely(PetscTruth cond) 365d382aafbSBarry Smith 366d382aafbSBarry Smith Input Parameters: 367d382aafbSBarry Smith . cond - condition or expression 368d382aafbSBarry Smith 369d382aafbSBarry Smith Note: This returns the same truth value, it is only a hint to compilers that the resulting 370d382aafbSBarry Smith branch is unlikely. 371d382aafbSBarry Smith 372d382aafbSBarry Smith Level: advanced 373d382aafbSBarry Smith 374d382aafbSBarry Smith .seealso: PetscLikely(), CHKERRQ 375d382aafbSBarry Smith M*/ 376d382aafbSBarry Smith 377d382aafbSBarry Smith /*MC 378d382aafbSBarry Smith PetscLikely - hints the compiler that the given condition is usually TRUE 379d382aafbSBarry Smith 380d382aafbSBarry Smith Not Collective 381d382aafbSBarry Smith 382d382aafbSBarry Smith Synopsis: 383d382aafbSBarry Smith PetscTruth PetscUnlikely(PetscTruth cond) 384d382aafbSBarry Smith 385d382aafbSBarry Smith Input Parameters: 386d382aafbSBarry Smith . cond - condition or expression 387d382aafbSBarry Smith 388d382aafbSBarry Smith Note: This returns the same truth value, it is only a hint to compilers that the resulting 389d382aafbSBarry Smith branch is likely. 390d382aafbSBarry Smith 391d382aafbSBarry Smith Level: advanced 392d382aafbSBarry Smith 393d382aafbSBarry Smith .seealso: PetscUnlikely() 394d382aafbSBarry Smith M*/ 395d382aafbSBarry Smith #if defined(PETSC_HAVE_BUILTIN_EXPECT) 396d382aafbSBarry Smith # define PetscUnlikely(cond) __builtin_expect(!!(cond),0) 397d382aafbSBarry Smith # define PetscLikely(cond) __builtin_expect(!!(cond),1) 398d382aafbSBarry Smith #else 399d382aafbSBarry Smith # define PetscUnlikely(cond) cond 400d382aafbSBarry Smith # define PetscLikely(cond) cond 401d382aafbSBarry Smith #endif 402d382aafbSBarry Smith 403d382aafbSBarry Smith /* 404d382aafbSBarry Smith Extern indicates a PETSc function defined elsewhere 405d382aafbSBarry Smith */ 406d382aafbSBarry Smith #if !defined(EXTERN) 407d382aafbSBarry Smith #define EXTERN extern 408d382aafbSBarry Smith #endif 409d382aafbSBarry Smith 410d382aafbSBarry Smith /* 411d382aafbSBarry Smith Defines some elementary mathematics functions and constants. 412d382aafbSBarry Smith */ 413d382aafbSBarry Smith #include "petscmath.h" 414d382aafbSBarry Smith 415d382aafbSBarry Smith /* 416d382aafbSBarry Smith Declare extern C stuff after including external header files 417d382aafbSBarry Smith */ 418d382aafbSBarry Smith 419d382aafbSBarry Smith PETSC_EXTERN_CXX_BEGIN 420d382aafbSBarry Smith 421d382aafbSBarry Smith /* 422d382aafbSBarry Smith Basic PETSc constants 423d382aafbSBarry Smith */ 424d382aafbSBarry Smith 425d382aafbSBarry Smith /*E 426d382aafbSBarry Smith PetscTruth - Logical variable. Actually an integer 427d382aafbSBarry Smith 428d382aafbSBarry Smith Level: beginner 429d382aafbSBarry Smith 430d382aafbSBarry Smith E*/ 431d382aafbSBarry Smith typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth; 432d382aafbSBarry Smith extern const char *PetscTruths[]; 433d382aafbSBarry Smith 434d382aafbSBarry Smith /*MC 435d382aafbSBarry Smith PETSC_FALSE - False value of PetscTruth 436d382aafbSBarry Smith 437d382aafbSBarry Smith Level: beginner 438d382aafbSBarry Smith 439d382aafbSBarry Smith Note: Zero integer 440d382aafbSBarry Smith 441d382aafbSBarry Smith .seealso: PetscTruth, PETSC_TRUE 442d382aafbSBarry Smith M*/ 443d382aafbSBarry Smith 444d382aafbSBarry Smith /*MC 445d382aafbSBarry Smith PETSC_TRUE - True value of PetscTruth 446d382aafbSBarry Smith 447d382aafbSBarry Smith Level: beginner 448d382aafbSBarry Smith 449d382aafbSBarry Smith Note: Nonzero integer 450d382aafbSBarry Smith 451d382aafbSBarry Smith .seealso: PetscTruth, PETSC_FALSE 452d382aafbSBarry Smith M*/ 453d382aafbSBarry Smith 454d382aafbSBarry Smith /*MC 455d382aafbSBarry Smith PETSC_YES - Alias for PETSC_TRUE 456d382aafbSBarry Smith 457d382aafbSBarry Smith Level: beginner 458d382aafbSBarry Smith 459d382aafbSBarry Smith Note: Zero integer 460d382aafbSBarry Smith 461d382aafbSBarry Smith .seealso: PetscTruth, PETSC_TRUE, PETSC_FALSE, PETSC_NO 462d382aafbSBarry Smith M*/ 463d382aafbSBarry Smith #define PETSC_YES PETSC_TRUE 464d382aafbSBarry Smith 465d382aafbSBarry Smith /*MC 466d382aafbSBarry Smith PETSC_NO - Alias for PETSC_FALSE 467d382aafbSBarry Smith 468d382aafbSBarry Smith Level: beginner 469d382aafbSBarry Smith 470d382aafbSBarry Smith Note: Nonzero integer 471d382aafbSBarry Smith 472d382aafbSBarry Smith .seealso: PetscTruth, PETSC_TRUE, PETSC_FALSE, PETSC_YES 473d382aafbSBarry Smith M*/ 474d382aafbSBarry Smith #define PETSC_NO PETSC_FALSE 475d382aafbSBarry Smith 476d382aafbSBarry Smith /*MC 477d382aafbSBarry Smith PETSC_NULL - standard way of passing in a null or array or pointer 478d382aafbSBarry Smith 479d382aafbSBarry Smith Level: beginner 480d382aafbSBarry Smith 481d382aafbSBarry Smith Notes: accepted by many PETSc functions to not set a parameter and instead use 482d382aafbSBarry Smith some default 483d382aafbSBarry Smith 484d382aafbSBarry Smith This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER, 485d382aafbSBarry Smith PETSC_NULL_DOUBLE_PRECISION etc 486d382aafbSBarry Smith 487d382aafbSBarry Smith .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE 488d382aafbSBarry Smith 489d382aafbSBarry Smith M*/ 490d382aafbSBarry Smith #define PETSC_NULL 0 491d382aafbSBarry Smith 492d382aafbSBarry Smith /*MC 493d382aafbSBarry Smith PETSC_DECIDE - standard way of passing in integer or floating point parameter 494d382aafbSBarry Smith where you wish PETSc to use the default. 495d382aafbSBarry Smith 496d382aafbSBarry Smith Level: beginner 497d382aafbSBarry Smith 498d382aafbSBarry Smith .seealso: PETSC_NULL, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE 499d382aafbSBarry Smith 500d382aafbSBarry Smith M*/ 501d382aafbSBarry Smith #define PETSC_DECIDE -1 502d382aafbSBarry Smith 503d382aafbSBarry Smith /*MC 504d382aafbSBarry Smith PETSC_DEFAULT - standard way of passing in integer or floating point parameter 505d382aafbSBarry Smith where you wish PETSc to use the default. 506d382aafbSBarry Smith 507d382aafbSBarry Smith Level: beginner 508d382aafbSBarry Smith 509d382aafbSBarry Smith Fortran Notes: You need to use PETSC_DEFAULT_INTEGER or PETSC_DEFAULT_DOUBLE_PRECISION. 510d382aafbSBarry Smith 511d382aafbSBarry Smith .seealso: PETSC_DECIDE, PETSC_NULL, PETSC_IGNORE, PETSC_DETERMINE 512d382aafbSBarry Smith 513d382aafbSBarry Smith M*/ 514d382aafbSBarry Smith #define PETSC_DEFAULT -2 515d382aafbSBarry Smith 516d382aafbSBarry Smith 517d382aafbSBarry Smith /*MC 518d382aafbSBarry Smith PETSC_IGNORE - same as PETSC_NULL, means PETSc will ignore this argument 519d382aafbSBarry Smith 520d382aafbSBarry Smith Level: beginner 521d382aafbSBarry Smith 522d382aafbSBarry Smith Note: accepted by many PETSc functions to not set a parameter and instead use 523d382aafbSBarry Smith some default 524d382aafbSBarry Smith 525d382aafbSBarry Smith Fortran Notes: This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER, 526d382aafbSBarry Smith PETSC_NULL_DOUBLE_PRECISION etc 527d382aafbSBarry Smith 528d382aafbSBarry Smith .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_NULL, PETSC_DETERMINE 529d382aafbSBarry Smith 530d382aafbSBarry Smith M*/ 531d382aafbSBarry Smith #define PETSC_IGNORE PETSC_NULL 532d382aafbSBarry Smith 533d382aafbSBarry Smith /*MC 534d382aafbSBarry Smith PETSC_DETERMINE - standard way of passing in integer or floating point parameter 535d382aafbSBarry Smith where you wish PETSc to compute the required value. 536d382aafbSBarry Smith 537d382aafbSBarry Smith Level: beginner 538d382aafbSBarry Smith 539d382aafbSBarry Smith .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_NULL, VecSetSizes() 540d382aafbSBarry Smith 541d382aafbSBarry Smith M*/ 542d382aafbSBarry Smith #define PETSC_DETERMINE PETSC_DECIDE 543d382aafbSBarry Smith 544d382aafbSBarry Smith /*MC 545d382aafbSBarry Smith PETSC_COMM_WORLD - the equivalent of the MPI_COMM_WORLD communicator which represents 546d382aafbSBarry Smith all the processs that PETSc knows about. 547d382aafbSBarry Smith 548d382aafbSBarry Smith Level: beginner 549d382aafbSBarry Smith 550d382aafbSBarry Smith Notes: By default PETSC_COMM_WORLD and MPI_COMM_WORLD are identical unless you wish to 551d382aafbSBarry Smith run PETSc on ONLY a subset of MPI_COMM_WORLD. In that case create your new (smaller) 552d382aafbSBarry Smith communicator, call it, say comm, and set PETSC_COMM_WORLD = comm BEFORE calling 553d382aafbSBarry Smith PetscInitialize() 554d382aafbSBarry Smith 555d382aafbSBarry Smith .seealso: PETSC_COMM_SELF 556d382aafbSBarry Smith 557d382aafbSBarry Smith M*/ 558d382aafbSBarry Smith extern MPI_Comm PETSC_COMM_WORLD; 559d382aafbSBarry Smith 560d382aafbSBarry Smith /*MC 561d382aafbSBarry Smith PETSC_COMM_SELF - a duplicate of the MPI_COMM_SELF communicator which represents 562d382aafbSBarry Smith the current process 563d382aafbSBarry Smith 564d382aafbSBarry Smith Level: beginner 565d382aafbSBarry Smith 566d382aafbSBarry Smith Notes: PETSC_COMM_SELF and MPI_COMM_SELF are equivalent. 567d382aafbSBarry Smith 568d382aafbSBarry Smith .seealso: PETSC_COMM_WORLD 569d382aafbSBarry Smith 570d382aafbSBarry Smith M*/ 571d382aafbSBarry Smith #define PETSC_COMM_SELF MPI_COMM_SELF 572d382aafbSBarry Smith 573d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscTruth PetscInitializeCalled; 574d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscTruth PetscFinalizeCalled; 575d382aafbSBarry Smith 576d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetHelpVersionFunctions(PetscErrorCode (*)(MPI_Comm),PetscErrorCode (*)(MPI_Comm)); 577d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscCommDuplicate(MPI_Comm,MPI_Comm*,int*); 578d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscCommDestroy(MPI_Comm*); 579d382aafbSBarry Smith 580d382aafbSBarry Smith /*MC 581d382aafbSBarry Smith PetscMalloc - Allocates memory 582d382aafbSBarry Smith 583d382aafbSBarry Smith Input Parameter: 584d382aafbSBarry Smith . m - number of bytes to allocate 585d382aafbSBarry Smith 586d382aafbSBarry Smith Output Parameter: 587d382aafbSBarry Smith . result - memory allocated 588d382aafbSBarry Smith 589d382aafbSBarry Smith Synopsis: 590d382aafbSBarry Smith PetscErrorCode PetscMalloc(size_t m,void **result) 591d382aafbSBarry Smith 592d382aafbSBarry Smith Level: beginner 593d382aafbSBarry Smith 594d382aafbSBarry Smith Notes: Memory is always allocated at least double aligned 595d382aafbSBarry Smith 596d382aafbSBarry Smith If you request memory of zero size it will allocate no space and assign the pointer to 0; PetscFree() will 597d382aafbSBarry Smith properly handle not freeing the null pointer. 598d382aafbSBarry Smith 599d382aafbSBarry Smith .seealso: PetscFree(), PetscNew() 600d382aafbSBarry Smith 601d382aafbSBarry Smith Concepts: memory allocation 602d382aafbSBarry Smith 603d382aafbSBarry Smith M*/ 604d382aafbSBarry Smith #define PetscMalloc(a,b) ((a != 0) ? (*PetscTrMalloc)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__,(void**)(b)) : (*(b) = 0,0) ) 605d382aafbSBarry Smith 606d382aafbSBarry Smith /*MC 607d382aafbSBarry Smith PetscAddrAlign - Returns an address with PETSC_MEMALIGN alignment 608d382aafbSBarry Smith 609d382aafbSBarry Smith Input Parameters: 610d382aafbSBarry Smith . addr - address to align (any pointer type) 611d382aafbSBarry Smith 612d382aafbSBarry Smith Synopsis: 613d382aafbSBarry Smith void *PetscAddrAlign(void *addr) 614d382aafbSBarry Smith 615d382aafbSBarry Smith Level: developer 616d382aafbSBarry Smith 617d382aafbSBarry Smith .seealso: PetscMallocAlign() 618d382aafbSBarry Smith 619d382aafbSBarry Smith Concepts: memory allocation 620d382aafbSBarry Smith M*/ 621d382aafbSBarry Smith #if defined PETSC_UINTPTR_T 622d382aafbSBarry Smith # define PetscAddrAlign(a) (void*)((((PETSC_UINTPTR_T)(a))+(PETSC_MEMALIGN-1)) & ~(PETSC_MEMALIGN-1)) 623d382aafbSBarry Smith #else 624d382aafbSBarry Smith # define PetscAddrAlign(a) (void*)(a) 625d382aafbSBarry Smith #endif 626d382aafbSBarry Smith 627d382aafbSBarry Smith /*MC 628d382aafbSBarry Smith PetscMalloc2 - Allocates 2 chunks of memory 629d382aafbSBarry Smith 630d382aafbSBarry Smith Input Parameter: 631d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 632d382aafbSBarry Smith . t1 - type of first memory elements 633d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 634d382aafbSBarry Smith - t2 - type of second memory elements 635d382aafbSBarry Smith 636d382aafbSBarry Smith Output Parameter: 637d382aafbSBarry Smith + r1 - memory allocated in first chunk 638d382aafbSBarry Smith - r2 - memory allocated in second chunk 639d382aafbSBarry Smith 640d382aafbSBarry Smith Synopsis: 641d382aafbSBarry Smith PetscErrorCode PetscMalloc2(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2) 642d382aafbSBarry Smith 643d382aafbSBarry Smith Level: developer 644d382aafbSBarry Smith 645d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 646d382aafbSBarry Smith 647d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc() 648d382aafbSBarry Smith 649d382aafbSBarry Smith Concepts: memory allocation 650d382aafbSBarry Smith 651d382aafbSBarry Smith M*/ 652d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 653d382aafbSBarry Smith #define PetscMalloc2(m1,t1,r1,m2,t2,r2) (PetscMalloc((m1)*sizeof(t1),r1) || PetscMalloc((m2)*sizeof(t2),r2)) 654d382aafbSBarry Smith #else 655*3b98c0a2SBarry Smith #define PetscMalloc2(m1,t1,r1,m2,t2,r2) ((*(r2) = 0,PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(PETSC_MEMALIGN-1),r1)) \ 656d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),0)) 657d382aafbSBarry Smith #endif 658d382aafbSBarry Smith 659d382aafbSBarry Smith /*MC 660d382aafbSBarry Smith PetscMalloc3 - Allocates 3 chunks of memory 661d382aafbSBarry Smith 662d382aafbSBarry Smith Input Parameter: 663d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 664d382aafbSBarry Smith . t1 - type of first memory elements 665d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 666d382aafbSBarry Smith . t2 - type of second memory elements 667d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 668d382aafbSBarry Smith - t3 - type of third memory elements 669d382aafbSBarry Smith 670d382aafbSBarry Smith Output Parameter: 671d382aafbSBarry Smith + r1 - memory allocated in first chunk 672d382aafbSBarry Smith . r2 - memory allocated in second chunk 673d382aafbSBarry Smith - r3 - memory allocated in third chunk 674d382aafbSBarry Smith 675d382aafbSBarry Smith Synopsis: 676d382aafbSBarry Smith PetscErrorCode PetscMalloc3(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2,size_t m3,type t3,void **r3) 677d382aafbSBarry Smith 678d382aafbSBarry Smith Level: developer 679d382aafbSBarry Smith 680d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 681d382aafbSBarry Smith 682d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3() 683d382aafbSBarry Smith 684d382aafbSBarry Smith Concepts: memory allocation 685d382aafbSBarry Smith 686d382aafbSBarry Smith M*/ 687d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 688d382aafbSBarry Smith #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)) 689d382aafbSBarry Smith #else 690*3b98c0a2SBarry Smith #define PetscMalloc3(m1,t1,r1,m2,t2,r2,m3,t3,r3) ((*(r2) = 0,*(r3) = 0,PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3)+2*(PETSC_MEMALIGN-1),r1)) \ 691d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),*(r3) = (t3*)PetscAddrAlign(*(r2)+m2),0)) 692d382aafbSBarry Smith #endif 693d382aafbSBarry Smith 694d382aafbSBarry Smith /*MC 695d382aafbSBarry Smith PetscMalloc4 - Allocates 4 chunks of memory 696d382aafbSBarry Smith 697d382aafbSBarry Smith Input Parameter: 698d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 699d382aafbSBarry Smith . t1 - type of first memory elements 700d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 701d382aafbSBarry Smith . t2 - type of second memory elements 702d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 703d382aafbSBarry Smith . t3 - type of third memory elements 704d382aafbSBarry Smith . m4 - number of elements to allocate in 4th chunk (may be zero) 705d382aafbSBarry Smith - t4 - type of fourth memory elements 706d382aafbSBarry Smith 707d382aafbSBarry Smith Output Parameter: 708d382aafbSBarry Smith + r1 - memory allocated in first chunk 709d382aafbSBarry Smith . r2 - memory allocated in second chunk 710d382aafbSBarry Smith . r3 - memory allocated in third chunk 711d382aafbSBarry Smith - r4 - memory allocated in fourth chunk 712d382aafbSBarry Smith 713d382aafbSBarry Smith Synopsis: 714d382aafbSBarry Smith 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) 715d382aafbSBarry Smith 716d382aafbSBarry Smith Level: developer 717d382aafbSBarry Smith 718d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 719d382aafbSBarry Smith 720d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4() 721d382aafbSBarry Smith 722d382aafbSBarry Smith Concepts: memory allocation 723d382aafbSBarry Smith 724d382aafbSBarry Smith M*/ 725d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 726d382aafbSBarry Smith #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)) 727d382aafbSBarry Smith #else 728d382aafbSBarry Smith #define PetscMalloc4(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4) \ 729*3b98c0a2SBarry Smith ((*(r2) = 0, *(r3) = 0, *(r4) = 0,PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3)+(m4)*sizeof(t4)+3*(PETSC_MEMALIGN-1),r1)) \ 730d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),*(r3) = (t3*)PetscAddrAlign(*(r2)+m2),*(r4) = (t4*)PetscAddrAlign(*(r3)+m3),0)) 731d382aafbSBarry Smith #endif 732d382aafbSBarry Smith 733d382aafbSBarry Smith /*MC 734d382aafbSBarry Smith PetscMalloc5 - Allocates 5 chunks of memory 735d382aafbSBarry Smith 736d382aafbSBarry Smith Input Parameter: 737d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 738d382aafbSBarry Smith . t1 - type of first memory elements 739d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 740d382aafbSBarry Smith . t2 - type of second memory elements 741d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 742d382aafbSBarry Smith . t3 - type of third memory elements 743d382aafbSBarry Smith . m4 - number of elements to allocate in 4th chunk (may be zero) 744d382aafbSBarry Smith . t4 - type of fourth memory elements 745d382aafbSBarry Smith . m5 - number of elements to allocate in 5th chunk (may be zero) 746d382aafbSBarry Smith - t5 - type of fifth memory elements 747d382aafbSBarry Smith 748d382aafbSBarry Smith Output Parameter: 749d382aafbSBarry Smith + r1 - memory allocated in first chunk 750d382aafbSBarry Smith . r2 - memory allocated in second chunk 751d382aafbSBarry Smith . r3 - memory allocated in third chunk 752d382aafbSBarry Smith . r4 - memory allocated in fourth chunk 753d382aafbSBarry Smith - r5 - memory allocated in fifth chunk 754d382aafbSBarry Smith 755d382aafbSBarry Smith Synopsis: 756d382aafbSBarry Smith 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) 757d382aafbSBarry Smith 758d382aafbSBarry Smith Level: developer 759d382aafbSBarry Smith 760d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 761d382aafbSBarry Smith 762d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5() 763d382aafbSBarry Smith 764d382aafbSBarry Smith Concepts: memory allocation 765d382aafbSBarry Smith 766d382aafbSBarry Smith M*/ 767d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 768d382aafbSBarry Smith #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)) 769d382aafbSBarry Smith #else 770d382aafbSBarry Smith #define PetscMalloc5(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5) \ 771*3b98c0a2SBarry Smith ((*(r2) = 0, *(r3) = 0, *(r4) = 0,*(r5) = 0,PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3)+(m4)*sizeof(t4)+(m5)*sizeof(t5)+4*(PETSC_MEMALIGN-1),r1)) \ 772d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),*(r3) = (t3*)PetscAddrAlign(*(r2)+m2),*(r4) = (t4*)PetscAddrAlign(*(r3)+m3),*(r5) = (t5*)PetscAddrAlign(*(r4)+m4),0)) 773d382aafbSBarry Smith #endif 774d382aafbSBarry Smith 775d382aafbSBarry Smith 776d382aafbSBarry Smith /*MC 777d382aafbSBarry Smith PetscMalloc6 - Allocates 6 chunks of memory 778d382aafbSBarry Smith 779d382aafbSBarry Smith Input Parameter: 780d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 781d382aafbSBarry Smith . t1 - type of first memory elements 782d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 783d382aafbSBarry Smith . t2 - type of second memory elements 784d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 785d382aafbSBarry Smith . t3 - type of third memory elements 786d382aafbSBarry Smith . m4 - number of elements to allocate in 4th chunk (may be zero) 787d382aafbSBarry Smith . t4 - type of fourth memory elements 788d382aafbSBarry Smith . m5 - number of elements to allocate in 5th chunk (may be zero) 789d382aafbSBarry Smith . t5 - type of fifth memory elements 790d382aafbSBarry Smith . m6 - number of elements to allocate in 6th chunk (may be zero) 791d382aafbSBarry Smith - t6 - type of sixth memory elements 792d382aafbSBarry Smith 793d382aafbSBarry Smith Output Parameter: 794d382aafbSBarry Smith + r1 - memory allocated in first chunk 795d382aafbSBarry Smith . r2 - memory allocated in second chunk 796d382aafbSBarry Smith . r3 - memory allocated in third chunk 797d382aafbSBarry Smith . r4 - memory allocated in fourth chunk 798d382aafbSBarry Smith . r5 - memory allocated in fifth chunk 799d382aafbSBarry Smith - r6 - memory allocated in sixth chunk 800d382aafbSBarry Smith 801d382aafbSBarry Smith Synopsis: 802d382aafbSBarry Smith 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) 803d382aafbSBarry Smith 804d382aafbSBarry Smith Level: developer 805d382aafbSBarry Smith 806d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 807d382aafbSBarry Smith 808d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5(), PetscFree6() 809d382aafbSBarry Smith 810d382aafbSBarry Smith Concepts: memory allocation 811d382aafbSBarry Smith 812d382aafbSBarry Smith M*/ 813d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 814d382aafbSBarry Smith #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)) 815d382aafbSBarry Smith #else 816d382aafbSBarry Smith #define PetscMalloc6(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5,m6,t6,r6) \ 817*3b98c0a2SBarry Smith ((*(r2) = 0, *(r3) = 0, *(r4) = 0,*(r5) = 0,*(r6) = 0,PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3)+(m4)*sizeof(t4)+(m5)*sizeof(t5)+(m6)*sizeof(t6)+5*(PETSC_MEMALIGN-1),r1)) \ 818d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),*(r3) = (t3*)PetscAddrAlign(*(r2)+m2),*(r4) = (t4*)PetscAddrAlign(*(r3)+m3),*(r5) = (t5*)PetscAddrAlign(*(r4)+m4),*(r6) = (t6*)PetscAddrAlign(*(r5)+m5),0)) 819d382aafbSBarry Smith #endif 820d382aafbSBarry Smith 821d382aafbSBarry Smith /*MC 822d382aafbSBarry Smith PetscMalloc7 - Allocates 7 chunks of memory 823d382aafbSBarry Smith 824d382aafbSBarry Smith Input Parameter: 825d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 826d382aafbSBarry Smith . t1 - type of first memory elements 827d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 828d382aafbSBarry Smith . t2 - type of second memory elements 829d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 830d382aafbSBarry Smith . t3 - type of third memory elements 831d382aafbSBarry Smith . m4 - number of elements to allocate in 4th chunk (may be zero) 832d382aafbSBarry Smith . t4 - type of fourth memory elements 833d382aafbSBarry Smith . m5 - number of elements to allocate in 5th chunk (may be zero) 834d382aafbSBarry Smith . t5 - type of fifth memory elements 835d382aafbSBarry Smith . m6 - number of elements to allocate in 6th chunk (may be zero) 836d382aafbSBarry Smith . t6 - type of sixth memory elements 837d382aafbSBarry Smith . m7 - number of elements to allocate in 7th chunk (may be zero) 838d382aafbSBarry Smith - t7 - type of sixth memory elements 839d382aafbSBarry Smith 840d382aafbSBarry Smith Output Parameter: 841d382aafbSBarry Smith + r1 - memory allocated in first chunk 842d382aafbSBarry Smith . r2 - memory allocated in second chunk 843d382aafbSBarry Smith . r3 - memory allocated in third chunk 844d382aafbSBarry Smith . r4 - memory allocated in fourth chunk 845d382aafbSBarry Smith . r5 - memory allocated in fifth chunk 846d382aafbSBarry Smith . r6 - memory allocated in sixth chunk 847d382aafbSBarry Smith - r7 - memory allocated in sixth chunk 848d382aafbSBarry Smith 849d382aafbSBarry Smith Synopsis: 850d382aafbSBarry Smith PetscErrorCode PetscMalloc7(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,size_t m7,type t7,void **r7) 851d382aafbSBarry Smith 852d382aafbSBarry Smith Level: developer 853d382aafbSBarry Smith 854d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 855d382aafbSBarry Smith 856d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5(), PetscFree6(), PetscFree7() 857d382aafbSBarry Smith 858d382aafbSBarry Smith Concepts: memory allocation 859d382aafbSBarry Smith 860d382aafbSBarry Smith M*/ 861d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 862d382aafbSBarry Smith #define PetscMalloc7(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5,m6,t6,r6,m7,t7,r7) (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) || PetscMalloc((m7)*sizeof(t7),r7)) 863d382aafbSBarry Smith #else 864d382aafbSBarry Smith #define PetscMalloc7(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5,m6,t6,r6,m7,t7,r7) \ 865*3b98c0a2SBarry Smith ((*(r2) = 0, *(r3) = 0, *(r4) = 0,*(r5) = 0,*(r6) = 0,*(r7) = 0,PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(m3)*sizeof(t3)+(m4)*sizeof(t4)+(m5)*sizeof(t5)+(m6)*sizeof(t6)+(m7)*sizeof(t7)+6*(PETSC_MEMALIGN-1),r1)) \ 866d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),*(r3) = (t3*)PetscAddrAlign(*(r2)+m2),*(r4) = (t4*)PetscAddrAlign(*(r3)+m3),*(r5) = (t5*)PetscAddrAlign(*(r4)+m4),*(r6) = (t6*)PetscAddrAlign(*(r5)+m5),*(r7) = (t7*)PetscAddrAlign(*(r6)+m6),0)) 867d382aafbSBarry Smith #endif 868d382aafbSBarry Smith 869d382aafbSBarry Smith /*MC 870d382aafbSBarry Smith PetscNew - Allocates memory of a particular type, zeros the memory! 871d382aafbSBarry Smith 872d382aafbSBarry Smith Input Parameter: 873d382aafbSBarry Smith . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated 874d382aafbSBarry Smith 875d382aafbSBarry Smith Output Parameter: 876d382aafbSBarry Smith . result - memory allocated 877d382aafbSBarry Smith 878d382aafbSBarry Smith Synopsis: 879d382aafbSBarry Smith PetscErrorCode PetscNew(struct type,((type *))result) 880d382aafbSBarry Smith 881d382aafbSBarry Smith Level: beginner 882d382aafbSBarry Smith 883d382aafbSBarry Smith .seealso: PetscFree(), PetscMalloc() 884d382aafbSBarry Smith 885d382aafbSBarry Smith Concepts: memory allocation 886d382aafbSBarry Smith 887d382aafbSBarry Smith M*/ 888d382aafbSBarry Smith #define PetscNew(A,b) (PetscMalloc(sizeof(A),(b)) || PetscMemzero(*(b),sizeof(A))) 889d382aafbSBarry Smith #define PetscNewLog(o,A,b) (PetscNew(A,b) || ((o) ? PetscLogObjectMemory(o,sizeof(A)) : 0)) 890d382aafbSBarry Smith 891d382aafbSBarry Smith /*MC 892d382aafbSBarry Smith PetscFree - Frees memory 893d382aafbSBarry Smith 894d382aafbSBarry Smith Input Parameter: 895d382aafbSBarry Smith . memory - memory to free (the pointer is ALWAYS set to 0 upon sucess) 896d382aafbSBarry Smith 897d382aafbSBarry Smith Synopsis: 898d382aafbSBarry Smith PetscErrorCode PetscFree(void *memory) 899d382aafbSBarry Smith 900d382aafbSBarry Smith Level: beginner 901d382aafbSBarry Smith 902d382aafbSBarry Smith Notes: Memory must have been obtained with PetscNew() or PetscMalloc() 903d382aafbSBarry Smith 904d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscFreeVoid() 905d382aafbSBarry Smith 906d382aafbSBarry Smith Concepts: memory allocation 907d382aafbSBarry Smith 908d382aafbSBarry Smith M*/ 909d382aafbSBarry Smith #define PetscFree(a) ((a) ? ((*PetscTrFree)((void*)(a),__LINE__,__FUNCT__,__FILE__,__SDIR__) || ((a = 0),0)) : 0) 910d382aafbSBarry Smith 911d382aafbSBarry Smith /*MC 912d382aafbSBarry Smith PetscFreeVoid - Frees memory 913d382aafbSBarry Smith 914d382aafbSBarry Smith Input Parameter: 915d382aafbSBarry Smith . memory - memory to free 916d382aafbSBarry Smith 917d382aafbSBarry Smith Synopsis: 918d382aafbSBarry Smith void PetscFreeVoid(void *memory) 919d382aafbSBarry Smith 920d382aafbSBarry Smith Level: beginner 921d382aafbSBarry Smith 922d382aafbSBarry Smith Notes: This is different from PetscFree() in that no error code is returned 923d382aafbSBarry Smith 924d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc() 925d382aafbSBarry Smith 926d382aafbSBarry Smith Concepts: memory allocation 927d382aafbSBarry Smith 928d382aafbSBarry Smith M*/ 929d382aafbSBarry Smith #define PetscFreeVoid(a) ((*PetscTrFree)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__),(a) = 0) 930d382aafbSBarry Smith 931d382aafbSBarry Smith 932d382aafbSBarry Smith /*MC 933d382aafbSBarry Smith PetscFree2 - Frees 2 chunks of memory obtained with PetscMalloc2() 934d382aafbSBarry Smith 935d382aafbSBarry Smith Input Parameter: 936d382aafbSBarry Smith + memory1 - memory to free 937d382aafbSBarry Smith - memory2 - 2nd memory to free 938d382aafbSBarry Smith 939d382aafbSBarry Smith 940d382aafbSBarry Smith Synopsis: 941d382aafbSBarry Smith PetscErrorCode PetscFree2(void *memory1,void *memory2) 942d382aafbSBarry Smith 943d382aafbSBarry Smith Level: developer 944d382aafbSBarry Smith 945d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc2() 946d382aafbSBarry Smith 947d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree() 948d382aafbSBarry Smith 949d382aafbSBarry Smith Concepts: memory allocation 950d382aafbSBarry Smith 951d382aafbSBarry Smith M*/ 952d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 953d382aafbSBarry Smith #define PetscFree2(m1,m2) (PetscFree(m2) || PetscFree(m1)) 954d382aafbSBarry Smith #else 955d382aafbSBarry Smith #define PetscFree2(m1,m2) (PetscFree(m1)) 956d382aafbSBarry Smith #endif 957d382aafbSBarry Smith 958d382aafbSBarry Smith /*MC 959d382aafbSBarry Smith PetscFree3 - Frees 3 chunks of memory obtained with PetscMalloc3() 960d382aafbSBarry Smith 961d382aafbSBarry Smith Input Parameter: 962d382aafbSBarry Smith + memory1 - memory to free 963d382aafbSBarry Smith . memory2 - 2nd memory to free 964d382aafbSBarry Smith - memory3 - 3rd memory to free 965d382aafbSBarry Smith 966d382aafbSBarry Smith 967d382aafbSBarry Smith Synopsis: 968d382aafbSBarry Smith PetscErrorCode PetscFree3(void *memory1,void *memory2,void *memory3) 969d382aafbSBarry Smith 970d382aafbSBarry Smith Level: developer 971d382aafbSBarry Smith 972d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc3() 973d382aafbSBarry Smith 974d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3() 975d382aafbSBarry Smith 976d382aafbSBarry Smith Concepts: memory allocation 977d382aafbSBarry Smith 978d382aafbSBarry Smith M*/ 979d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 980d382aafbSBarry Smith #define PetscFree3(m1,m2,m3) (PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 981d382aafbSBarry Smith #else 982d382aafbSBarry Smith #define PetscFree3(m1,m2,m3) (PetscFree(m1)) 983d382aafbSBarry Smith #endif 984d382aafbSBarry Smith 985d382aafbSBarry Smith /*MC 986d382aafbSBarry Smith PetscFree4 - Frees 4 chunks of memory obtained with PetscMalloc4() 987d382aafbSBarry Smith 988d382aafbSBarry Smith Input Parameter: 989d382aafbSBarry Smith + m1 - memory to free 990d382aafbSBarry Smith . m2 - 2nd memory to free 991d382aafbSBarry Smith . m3 - 3rd memory to free 992d382aafbSBarry Smith - m4 - 4th memory to free 993d382aafbSBarry Smith 994d382aafbSBarry Smith 995d382aafbSBarry Smith Synopsis: 996d382aafbSBarry Smith PetscErrorCode PetscFree4(void *m1,void *m2,void *m3,void *m4) 997d382aafbSBarry Smith 998d382aafbSBarry Smith Level: developer 999d382aafbSBarry Smith 1000d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc4() 1001d382aafbSBarry Smith 1002d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4() 1003d382aafbSBarry Smith 1004d382aafbSBarry Smith Concepts: memory allocation 1005d382aafbSBarry Smith 1006d382aafbSBarry Smith M*/ 1007d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1008d382aafbSBarry Smith #define PetscFree4(m1,m2,m3,m4) (PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1009d382aafbSBarry Smith #else 1010d382aafbSBarry Smith #define PetscFree4(m1,m2,m3,m4) (PetscFree(m1)) 1011d382aafbSBarry Smith #endif 1012d382aafbSBarry Smith 1013d382aafbSBarry Smith /*MC 1014d382aafbSBarry Smith PetscFree5 - Frees 5 chunks of memory obtained with PetscMalloc5() 1015d382aafbSBarry Smith 1016d382aafbSBarry Smith Input Parameter: 1017d382aafbSBarry Smith + m1 - memory to free 1018d382aafbSBarry Smith . m2 - 2nd memory to free 1019d382aafbSBarry Smith . m3 - 3rd memory to free 1020d382aafbSBarry Smith . m4 - 4th memory to free 1021d382aafbSBarry Smith - m5 - 5th memory to free 1022d382aafbSBarry Smith 1023d382aafbSBarry Smith 1024d382aafbSBarry Smith Synopsis: 1025d382aafbSBarry Smith PetscErrorCode PetscFree5(void *m1,void *m2,void *m3,void *m4,void *m5) 1026d382aafbSBarry Smith 1027d382aafbSBarry Smith Level: developer 1028d382aafbSBarry Smith 1029d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc5() 1030d382aafbSBarry Smith 1031d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5() 1032d382aafbSBarry Smith 1033d382aafbSBarry Smith Concepts: memory allocation 1034d382aafbSBarry Smith 1035d382aafbSBarry Smith M*/ 1036d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1037d382aafbSBarry Smith #define PetscFree5(m1,m2,m3,m4,m5) (PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1038d382aafbSBarry Smith #else 1039d382aafbSBarry Smith #define PetscFree5(m1,m2,m3,m4,m5) (PetscFree(m1)) 1040d382aafbSBarry Smith #endif 1041d382aafbSBarry Smith 1042d382aafbSBarry Smith 1043d382aafbSBarry Smith /*MC 1044d382aafbSBarry Smith PetscFree6 - Frees 6 chunks of memory obtained with PetscMalloc6() 1045d382aafbSBarry Smith 1046d382aafbSBarry Smith Input Parameter: 1047d382aafbSBarry Smith + m1 - memory to free 1048d382aafbSBarry Smith . m2 - 2nd memory to free 1049d382aafbSBarry Smith . m3 - 3rd memory to free 1050d382aafbSBarry Smith . m4 - 4th memory to free 1051d382aafbSBarry Smith . m5 - 5th memory to free 1052d382aafbSBarry Smith - m6 - 6th memory to free 1053d382aafbSBarry Smith 1054d382aafbSBarry Smith 1055d382aafbSBarry Smith Synopsis: 1056d382aafbSBarry Smith PetscErrorCode PetscFree6(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6) 1057d382aafbSBarry Smith 1058d382aafbSBarry Smith Level: developer 1059d382aafbSBarry Smith 1060d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc6() 1061d382aafbSBarry Smith 1062d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5(), PetscMalloc6() 1063d382aafbSBarry Smith 1064d382aafbSBarry Smith Concepts: memory allocation 1065d382aafbSBarry Smith 1066d382aafbSBarry Smith M*/ 1067d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1068d382aafbSBarry Smith #define PetscFree6(m1,m2,m3,m4,m5,m6) (PetscFree(m6) || PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1069d382aafbSBarry Smith #else 1070d382aafbSBarry Smith #define PetscFree6(m1,m2,m3,m4,m5,m6) (PetscFree(m1)) 1071d382aafbSBarry Smith #endif 1072d382aafbSBarry Smith 1073d382aafbSBarry Smith /*MC 1074d382aafbSBarry Smith PetscFree7 - Frees 7 chunks of memory obtained with PetscMalloc7() 1075d382aafbSBarry Smith 1076d382aafbSBarry Smith Input Parameter: 1077d382aafbSBarry Smith + m1 - memory to free 1078d382aafbSBarry Smith . m2 - 2nd memory to free 1079d382aafbSBarry Smith . m3 - 3rd memory to free 1080d382aafbSBarry Smith . m4 - 4th memory to free 1081d382aafbSBarry Smith . m5 - 5th memory to free 1082d382aafbSBarry Smith . m6 - 6th memory to free 1083d382aafbSBarry Smith - m7 - 7th memory to free 1084d382aafbSBarry Smith 1085d382aafbSBarry Smith 1086d382aafbSBarry Smith Synopsis: 1087d382aafbSBarry Smith PetscErrorCode PetscFree7(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6,void *m7) 1088d382aafbSBarry Smith 1089d382aafbSBarry Smith Level: developer 1090d382aafbSBarry Smith 1091d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc7() 1092d382aafbSBarry Smith 1093d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5(), PetscMalloc6(), 1094d382aafbSBarry Smith PetscMalloc7() 1095d382aafbSBarry Smith 1096d382aafbSBarry Smith Concepts: memory allocation 1097d382aafbSBarry Smith 1098d382aafbSBarry Smith M*/ 1099d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1100d382aafbSBarry Smith #define PetscFree7(m1,m2,m3,m4,m5,m6,m7) (PetscFree(m7) || PetscFree(m6) || PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1101d382aafbSBarry Smith #else 1102d382aafbSBarry Smith #define PetscFree7(m1,m2,m3,m4,m5,m6,m7) (PetscFree(m1)) 1103d382aafbSBarry Smith #endif 1104d382aafbSBarry Smith 1105d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT PetscErrorCode (*PetscTrMalloc)(size_t,int,const char[],const char[],const char[],void**); 1106d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT PetscErrorCode (*PetscTrFree)(void*,int,const char[],const char[],const char[]); 1107d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocSet(PetscErrorCode (*)(size_t,int,const char[],const char[],const char[],void**),PetscErrorCode (*)(void*,int,const char[],const char[],const char[])); 1108d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocClear(void); 1109d382aafbSBarry Smith 1110d382aafbSBarry Smith /* 1111d382aafbSBarry Smith Routines for tracing memory corruption/bleeding with default PETSc 1112d382aafbSBarry Smith memory allocation 1113d382aafbSBarry Smith */ 1114d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocDump(FILE *); 1115d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocDumpLog(FILE *); 1116d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocGetCurrentUsage(PetscLogDouble *); 1117d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocGetMaximumUsage(PetscLogDouble *); 1118d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocDebug(PetscTruth); 1119d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocValidate(int,const char[],const char[],const char[]); 1120d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocSetDumpLog(void); 1121d382aafbSBarry Smith 1122d382aafbSBarry Smith 1123d382aafbSBarry Smith /* 1124d382aafbSBarry Smith Variable type where we stash PETSc object pointers in Fortran. 1125d382aafbSBarry Smith On most machines size(pointer) == sizeof(long) - except windows 1126d382aafbSBarry Smith where its sizeof(long long) 1127d382aafbSBarry Smith */ 1128d382aafbSBarry Smith 1129d382aafbSBarry Smith #if (PETSC_SIZEOF_VOID_P) == (PETSC_SIZEOF_LONG) 1130d382aafbSBarry Smith #define PetscFortranAddr long 1131d382aafbSBarry Smith #elif (PETSC_SIZEOF_VOID_P) == (PETSC_SIZEOF_LONG_LONG) 1132d382aafbSBarry Smith #define PetscFortranAddr long long 1133d382aafbSBarry Smith #else 1134d382aafbSBarry Smith #error "Unknown size for PetscFortranAddr! Send us a bugreport at petsc-maint@mcs.anl.gov" 1135d382aafbSBarry Smith #endif 1136d382aafbSBarry Smith 1137d382aafbSBarry Smith /*E 1138d382aafbSBarry Smith PetscDataType - Used for handling different basic data types. 1139d382aafbSBarry Smith 1140d382aafbSBarry Smith Level: beginner 1141d382aafbSBarry Smith 1142d382aafbSBarry Smith Developer comment: It would be nice if we could always just use MPI Datatypes, why can we not? 1143d382aafbSBarry Smith 1144d382aafbSBarry Smith .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(), 1145d382aafbSBarry Smith PetscDataTypeGetSize() 1146d382aafbSBarry Smith 1147d382aafbSBarry Smith E*/ 1148d382aafbSBarry Smith typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2, PETSC_LONG = 3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5, 1149d382aafbSBarry Smith PETSC_CHAR = 6,PETSC_LOGICAL = 7,PETSC_ENUM = 8,PETSC_TRUTH=9, PETSC_LONG_DOUBLE = 10, PETSC_QD_DD = 11} PetscDataType; 1150d382aafbSBarry Smith extern const char *PetscDataTypes[]; 1151d382aafbSBarry Smith 1152d382aafbSBarry Smith #if defined(PETSC_USE_COMPLEX) 1153d382aafbSBarry Smith #define PETSC_SCALAR PETSC_COMPLEX 1154d382aafbSBarry Smith #else 1155d382aafbSBarry Smith #if defined(PETSC_USE_SCALAR_SINGLE) 1156d382aafbSBarry Smith #define PETSC_SCALAR PETSC_FLOAT 1157d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_LONG_DOUBLE) 1158d382aafbSBarry Smith #define PETSC_SCALAR PETSC_LONG_DOUBLE 1159d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_INT) 1160d382aafbSBarry Smith #define PETSC_SCALAR PETSC_INT 1161d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_QD_DD) 1162d382aafbSBarry Smith #define PETSC_SCALAR PETSC_QD_DD 1163d382aafbSBarry Smith #else 1164d382aafbSBarry Smith #define PETSC_SCALAR PETSC_DOUBLE 1165d382aafbSBarry Smith #endif 1166d382aafbSBarry Smith #endif 1167d382aafbSBarry Smith #if defined(PETSC_USE_SCALAR_SINGLE) 1168d382aafbSBarry Smith #define PETSC_REAL PETSC_FLOAT 1169d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_LONG_DOUBLE) 1170d382aafbSBarry Smith #define PETSC_REAL PETSC_LONG_DOUBLE 1171d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_INT) 1172d382aafbSBarry Smith #define PETSC_REAL PETSC_INT 1173d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_QD_DD) 1174d382aafbSBarry Smith #define PETSC_REAL PETSC_QD_DD 1175d382aafbSBarry Smith #else 1176d382aafbSBarry Smith #define PETSC_REAL PETSC_DOUBLE 1177d382aafbSBarry Smith #endif 1178d382aafbSBarry Smith #define PETSC_FORTRANADDR PETSC_LONG 1179d382aafbSBarry Smith 1180d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*); 1181d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMPIDataTypeToPetscDataType(MPI_Datatype,PetscDataType*); 1182d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDataTypeGetSize(PetscDataType,size_t*); 1183d382aafbSBarry Smith 1184d382aafbSBarry Smith /* 1185d382aafbSBarry Smith Basic memory and string operations. These are usually simple wrappers 1186d382aafbSBarry Smith around the basic Unix system calls, but a few of them have additional 1187d382aafbSBarry Smith functionality and/or error checking. 1188d382aafbSBarry Smith */ 1189d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBitMemcpy(void*,PetscInt,const void*,PetscInt,PetscInt,PetscDataType); 1190d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemmove(void*,void *,size_t); 1191d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemcmp(const void*,const void*,size_t,PetscTruth *); 1192d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrlen(const char[],size_t*); 1193d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrcmp(const char[],const char[],PetscTruth *); 1194d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrgrt(const char[],const char[],PetscTruth *); 1195d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrcasecmp(const char[],const char[],PetscTruth*); 1196d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrncmp(const char[],const char[],size_t,PetscTruth*); 1197d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrcpy(char[],const char[]); 1198d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrcat(char[],const char[]); 1199d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrncat(char[],const char[],size_t); 1200d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrncpy(char[],const char[],size_t); 1201d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrchr(const char[],char,char *[]); 1202d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrtolower(char[]); 1203d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrrchr(const char[],char,char *[]); 1204d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrstr(const char[],const char[],char *[]); 1205d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrrstr(const char[],const char[],char *[]); 1206d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrallocpy(const char[],char *[]); 1207d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrreplace(MPI_Comm,const char[],char[],size_t); 1208d382aafbSBarry Smith #define PetscStrfree(a) ((a) ? PetscFree(a) : 0) 1209d382aafbSBarry Smith 1210d382aafbSBarry Smith 1211d382aafbSBarry Smith /*S 1212d382aafbSBarry Smith PetscToken - 'Token' used for managing tokenizing strings 1213d382aafbSBarry Smith 1214d382aafbSBarry Smith Level: intermediate 1215d382aafbSBarry Smith 1216d382aafbSBarry Smith .seealso: PetscTokenCreate(), PetscTokenFind(), PetscTokenDestroy() 1217d382aafbSBarry Smith S*/ 1218d382aafbSBarry Smith typedef struct _p_PetscToken* PetscToken; 1219d382aafbSBarry Smith 1220d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTokenCreate(const char[],const char,PetscToken*); 1221d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTokenFind(PetscToken,char *[]); 1222d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTokenDestroy(PetscToken); 1223d382aafbSBarry Smith 1224d382aafbSBarry Smith /* 1225d382aafbSBarry Smith These are MPI operations for MPI_Allreduce() etc 1226d382aafbSBarry Smith */ 1227d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT MPI_Op PetscMaxSum_Op; 1228d382aafbSBarry Smith #if defined(PETSC_USE_COMPLEX) && !defined(PETSC_HAVE_MPI_C_DOUBLE_COMPLEX) 1229d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT MPI_Op MPIU_SUM; 1230d382aafbSBarry Smith #else 1231d382aafbSBarry Smith #define MPIU_SUM MPI_SUM 1232d382aafbSBarry Smith #endif 1233d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMaxSum(MPI_Comm,const PetscInt[],PetscInt*,PetscInt*); 1234d382aafbSBarry Smith 1235d382aafbSBarry Smith /*S 1236d382aafbSBarry Smith PetscObject - any PETSc object, PetscViewer, Mat, Vec, KSP etc 1237d382aafbSBarry Smith 1238d382aafbSBarry Smith Level: beginner 1239d382aafbSBarry Smith 1240d382aafbSBarry Smith Note: This is the base class from which all objects appear. 1241d382aafbSBarry Smith 1242d382aafbSBarry Smith .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName() 1243d382aafbSBarry Smith S*/ 1244d382aafbSBarry Smith typedef struct _p_PetscObject* PetscObject; 1245d382aafbSBarry Smith 1246d382aafbSBarry Smith /*S 1247d382aafbSBarry Smith PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed 1248d382aafbSBarry Smith by string name 1249d382aafbSBarry Smith 1250d382aafbSBarry Smith Level: advanced 1251d382aafbSBarry Smith 1252d382aafbSBarry Smith .seealso: PetscFListAdd(), PetscFListDestroy() 1253d382aafbSBarry Smith S*/ 1254d382aafbSBarry Smith typedef struct _n_PetscFList *PetscFList; 1255d382aafbSBarry Smith 1256d382aafbSBarry Smith /*E 1257d382aafbSBarry Smith PetscFileMode - Access mode for a file. 1258d382aafbSBarry Smith 1259d382aafbSBarry Smith Level: beginner 1260d382aafbSBarry Smith 1261d382aafbSBarry Smith FILE_MODE_READ - open a file at its beginning for reading 1262d382aafbSBarry Smith 1263d382aafbSBarry Smith FILE_MODE_WRITE - open a file at its beginning for writing (will create if the file does not exist) 1264d382aafbSBarry Smith 1265d382aafbSBarry Smith FILE_MODE_APPEND - open a file at end for writing 1266d382aafbSBarry Smith 1267d382aafbSBarry Smith FILE_MODE_UPDATE - open a file for updating, meaning for reading and writing 1268d382aafbSBarry Smith 1269d382aafbSBarry Smith FILE_MODE_APPEND_UPDATE - open a file for updating, meaning for reading and writing, at the end 1270d382aafbSBarry Smith 1271d382aafbSBarry Smith .seealso: PetscViewerFileSetMode() 1272d382aafbSBarry Smith E*/ 1273d382aafbSBarry Smith typedef enum {FILE_MODE_READ, FILE_MODE_WRITE, FILE_MODE_APPEND, FILE_MODE_UPDATE, FILE_MODE_APPEND_UPDATE} PetscFileMode; 1274d382aafbSBarry Smith 1275d382aafbSBarry Smith #include "petscviewer.h" 1276d382aafbSBarry Smith #include "petscoptions.h" 1277d382aafbSBarry Smith 1278d382aafbSBarry Smith #define PETSC_SMALLEST_COOKIE 1211211 1279d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscCookie PETSC_LARGEST_COOKIE; 1280d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscCookie PETSC_OBJECT_COOKIE; 1281d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscCookieRegister(const char[],PetscCookie *); 1282d382aafbSBarry Smith 1283d382aafbSBarry Smith /* 1284d382aafbSBarry Smith Routines that get memory usage information from the OS 1285d382aafbSBarry Smith */ 1286d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemoryGetCurrentUsage(PetscLogDouble *); 1287d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemoryGetMaximumUsage(PetscLogDouble *); 1288d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemorySetGetMaximumUsage(void); 1289d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemoryShowUsage(PetscViewer,const char[]); 1290d382aafbSBarry Smith 1291d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInfoAllow(PetscTruth,const char []); 1292d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetTime(PetscLogDouble*); 1293d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetCPUTime(PetscLogDouble*); 1294d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSleep(PetscReal); 1295d382aafbSBarry Smith 1296d382aafbSBarry Smith /* 1297d382aafbSBarry Smith Initialization of PETSc 1298d382aafbSBarry Smith */ 1299d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInitialize(int*,char***,const char[],const char[]); 1300d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscInitialize,(int *argc,char ***args),(argc,args,PETSC_NULL,PETSC_NULL)) 1301d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInitializeNoArguments(void); 1302d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInitialized(PetscTruth *); 1303d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFinalized(PetscTruth *); 1304d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFinalize(void); 1305d382aafbSBarry Smith EXTERN PetscErrorCode PetscInitializeFortran(void); 1306d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetArgs(int*,char ***); 1307d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetArguments(char ***); 1308d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFreeArguments(char **); 1309d382aafbSBarry Smith 1310d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscEnd(void); 1311d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInitializePackage(const char[]); 1312d382aafbSBarry Smith 1313d382aafbSBarry Smith extern MPI_Comm PETSC_COMM_LOCAL_WORLD; 1314d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPMerge(PetscMPIInt,PetscErrorCode (*)(void*),void*); 1315d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPSpawn(PetscMPIInt); 1316d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPFinalize(void); 1317d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPRun(MPI_Comm,PetscErrorCode (*)(MPI_Comm,void *),void*); 1318d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPRunCtx(MPI_Comm,PetscErrorCode (*)(MPI_Comm,void*,void *),void*); 1319d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPFree(MPI_Comm,void*); 1320d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPMalloc(MPI_Comm,size_t,void**); 1321d382aafbSBarry Smith 1322d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPythonInitialize(const char[],const char[]); 1323d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPythonFinalize(void); 1324d382aafbSBarry Smith 1325d382aafbSBarry Smith /* 1326d382aafbSBarry Smith These are so that in extern C code we can caste function pointers to non-extern C 1327d382aafbSBarry Smith function pointers. Since the regular C++ code expects its function pointers to be 1328d382aafbSBarry Smith C++. 1329d382aafbSBarry Smith */ 1330d382aafbSBarry Smith typedef void (**PetscVoidStarFunction)(void); 1331d382aafbSBarry Smith typedef void (*PetscVoidFunction)(void); 1332d382aafbSBarry Smith typedef PetscErrorCode (*PetscErrorCodeFunction)(void); 1333d382aafbSBarry Smith 1334d382aafbSBarry Smith /* 1335d382aafbSBarry Smith PetscTryMethod - Queries an object for a method, if it exists then calls it. 1336d382aafbSBarry Smith These are intended to be used only inside PETSc functions. 1337d382aafbSBarry Smith */ 1338d382aafbSBarry Smith #define PetscTryMethod(obj,A,B,C) \ 1339d382aafbSBarry Smith 0;{ PetscErrorCode (*f)B, __ierr; \ 1340d382aafbSBarry Smith __ierr = PetscObjectQueryFunction((PetscObject)obj,A,(PetscVoidStarFunction)&f);CHKERRQ(__ierr); \ 1341d382aafbSBarry Smith if (f) {__ierr = (*f)C;CHKERRQ(__ierr);}\ 1342d382aafbSBarry Smith } 1343d382aafbSBarry Smith #define PetscUseMethod(obj,A,B,C) \ 1344d382aafbSBarry Smith 0;{ PetscErrorCode (*f)B, __ierr; \ 1345d382aafbSBarry Smith __ierr = PetscObjectQueryFunction((PetscObject)obj,A,(PetscVoidStarFunction)&f);CHKERRQ(__ierr); \ 1346d382aafbSBarry Smith if (f) {__ierr = (*f)C;CHKERRQ(__ierr);}\ 1347d382aafbSBarry Smith else {SETERRQ1(PETSC_ERR_SUP,"Cannot locate function %s in object",A);} \ 1348d382aafbSBarry Smith } 1349d382aafbSBarry Smith /* 1350d382aafbSBarry Smith Functions that can act on any PETSc object. 1351d382aafbSBarry Smith */ 1352d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectCreate(MPI_Comm,PetscObject*); 1353d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectCreateGeneric(MPI_Comm, PetscCookie, const char [], PetscObject *); 1354d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectDestroy(PetscObject); 1355d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectExists(PetscObject,PetscTruth*); 1356d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetComm(PetscObject,MPI_Comm *); 1357d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetCookie(PetscObject,PetscCookie *); 1358d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetType(PetscObject,const char []); 1359d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetType(PetscObject,const char *[]); 1360d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetName(PetscObject,const char[]); 1361d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetName(PetscObject,const char*[]); 1362d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetTabLevel(PetscObject,PetscInt); 1363d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetTabLevel(PetscObject,PetscInt*); 1364d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectIncrementTabLevel(PetscObject,PetscObject,PetscInt); 1365d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectReference(PetscObject); 1366d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetReference(PetscObject,PetscInt*); 1367d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectDereference(PetscObject); 1368d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetNewTag(PetscObject,PetscMPIInt *); 1369d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectView(PetscObject,PetscViewer); 1370d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectCompose(PetscObject,const char[],PetscObject); 1371d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectQuery(PetscObject,const char[],PetscObject *); 1372d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)(void)); 1373d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetFromOptions(PetscObject); 1374d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetUp(PetscObject); 1375d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscCommGetNewTag(MPI_Comm,PetscMPIInt *); 1376d382aafbSBarry Smith 1377d382aafbSBarry Smith /*MC 1378d382aafbSBarry Smith PetscObjectComposeFunctionDynamic - Associates a function with a given PETSc object. 1379d382aafbSBarry Smith 1380d382aafbSBarry Smith Collective on PetscObject 1381d382aafbSBarry Smith 1382d382aafbSBarry Smith Input Parameters: 1383d382aafbSBarry Smith + obj - the PETSc object; this must be cast with a (PetscObject), for example, 1384d382aafbSBarry Smith PetscObjectCompose((PetscObject)mat,...); 1385d382aafbSBarry Smith . name - name associated with the child function 1386d382aafbSBarry Smith . fname - name of the function 1387d382aafbSBarry Smith - ptr - function pointer (or PETSC_NULL if using dynamic libraries) 1388d382aafbSBarry Smith 1389d382aafbSBarry Smith Level: advanced 1390d382aafbSBarry Smith 1391d382aafbSBarry Smith Synopsis: 1392d382aafbSBarry Smith PetscErrorCode PetscObjectComposeFunctionDynamic(PetscObject obj,const char name[],const char fname[],void *ptr) 1393d382aafbSBarry Smith 1394d382aafbSBarry Smith Notes: 1395d382aafbSBarry Smith To remove a registered routine, pass in a PETSC_NULL rname and fnc(). 1396d382aafbSBarry Smith 1397d382aafbSBarry Smith PetscObjectComposeFunctionDynamic() can be used with any PETSc object (such as 1398d382aafbSBarry Smith Mat, Vec, KSP, SNES, etc.) or any user-provided object. 1399d382aafbSBarry Smith 1400d382aafbSBarry Smith The composed function must be wrapped in a EXTERN_C_BEGIN/END for this to 1401d382aafbSBarry Smith work in C++/complex with dynamic link libraries (config/configure.py options --with-shared --with-dynamic) 1402d382aafbSBarry Smith enabled. 1403d382aafbSBarry Smith 1404d382aafbSBarry Smith Concepts: objects^composing functions 1405d382aafbSBarry Smith Concepts: composing functions 1406d382aafbSBarry Smith Concepts: functions^querying 1407d382aafbSBarry Smith Concepts: objects^querying 1408d382aafbSBarry Smith Concepts: querying objects 1409d382aafbSBarry Smith 1410d382aafbSBarry Smith .seealso: PetscObjectQueryFunction() 1411d382aafbSBarry Smith M*/ 1412d382aafbSBarry Smith #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 1413d382aafbSBarry Smith #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0) 1414d382aafbSBarry Smith #else 1415d382aafbSBarry Smith #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(PetscVoidFunction)(d)) 1416d382aafbSBarry Smith #endif 1417d382aafbSBarry Smith 1418d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectQueryFunction(PetscObject,const char[],void (**)(void)); 1419d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetOptionsPrefix(PetscObject,const char[]); 1420d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 1421d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectPrependOptionsPrefix(PetscObject,const char[]); 1422d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetOptionsPrefix(PetscObject,const char*[]); 1423d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectPublish(PetscObject); 1424d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectChangeTypeName(PetscObject,const char[]); 1425d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectRegisterDestroy(PetscObject); 1426d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectRegisterDestroyAll(void); 1427d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectName(PetscObject); 1428d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTypeCompare(PetscObject,const char[],PetscTruth*); 1429d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRegisterFinalize(PetscErrorCode (*)(void)); 1430d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRegisterFinalizeAll(void); 1431d382aafbSBarry Smith 1432d382aafbSBarry Smith /* 1433d382aafbSBarry Smith Defines PETSc error handling. 1434d382aafbSBarry Smith */ 1435d382aafbSBarry Smith #include "petscerror.h" 1436d382aafbSBarry Smith 1437d382aafbSBarry Smith /*S 1438d382aafbSBarry Smith PetscOList - Linked list of PETSc objects, accessable by string name 1439d382aafbSBarry Smith 1440d382aafbSBarry Smith Level: advanced 1441d382aafbSBarry Smith 1442d382aafbSBarry Smith .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind() 1443d382aafbSBarry Smith S*/ 1444d382aafbSBarry Smith typedef struct _n_PetscOList *PetscOList; 1445d382aafbSBarry Smith 1446d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListDestroy(PetscOList); 1447d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListFind(PetscOList,const char[],PetscObject*); 1448d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListReverseFind(PetscOList,PetscObject,char**); 1449d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListAdd(PetscOList *,const char[],PetscObject); 1450d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListDuplicate(PetscOList,PetscOList *); 1451d382aafbSBarry Smith 1452d382aafbSBarry Smith /* 1453d382aafbSBarry Smith Dynamic library lists. Lists of names of routines in dynamic 1454d382aafbSBarry Smith link libraries that will be loaded as needed. 1455d382aafbSBarry Smith */ 1456d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void)); 1457d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListDestroy(PetscFList*); 1458d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListFind(PetscFList,MPI_Comm,const char[],void (**)(void)); 1459d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],const char[],const char[],PetscFList,const char[]); 1460d382aafbSBarry Smith #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 1461d382aafbSBarry Smith #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0) 1462d382aafbSBarry Smith #else 1463d382aafbSBarry Smith #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c) 1464d382aafbSBarry Smith #endif 1465d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListDuplicate(PetscFList,PetscFList *); 1466d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListView(PetscFList,PetscViewer); 1467d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListConcat(const char [],const char [],char []); 1468d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListGet(PetscFList,char ***,int*); 1469d382aafbSBarry Smith 1470d382aafbSBarry Smith /*S 1471d382aafbSBarry Smith PetscDLLibrary - Linked list of dynamics libraries to search for functions 1472d382aafbSBarry Smith 1473d382aafbSBarry Smith Level: advanced 1474d382aafbSBarry Smith 1475d382aafbSBarry Smith --with-shared --with-dynamic must be used with config/configure.py to use dynamic libraries 1476d382aafbSBarry Smith 1477d382aafbSBarry Smith .seealso: PetscDLLibraryOpen() 1478d382aafbSBarry Smith S*/ 1479d382aafbSBarry Smith typedef struct _n_PetscDLLibrary *PetscDLLibrary; 1480d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscDLLibrary DLLibrariesLoaded; 1481d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryAppend(MPI_Comm,PetscDLLibrary *,const char[]); 1482d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryPrepend(MPI_Comm,PetscDLLibrary *,const char[]); 1483d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibrarySym(MPI_Comm,PetscDLLibrary *,const char[],const char[],void **); 1484d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryPrintPath(PetscDLLibrary); 1485d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,size_t,PetscTruth *); 1486d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryOpen(MPI_Comm,const char[],PetscDLLibrary *); 1487d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryClose(PetscDLLibrary); 1488d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryCCAAppend(MPI_Comm,PetscDLLibrary *,const char[]); 1489d382aafbSBarry Smith 1490d382aafbSBarry Smith /* 1491d382aafbSBarry Smith Useful utility routines 1492d382aafbSBarry Smith */ 1493d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSplitOwnership(MPI_Comm,PetscInt*,PetscInt*); 1494d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSplitOwnershipBlock(MPI_Comm,PetscInt,PetscInt*,PetscInt*); 1495d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSequentialPhaseBegin(MPI_Comm,PetscMPIInt); 1496d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscSequentialPhaseBegin,(MPI_Comm comm),(comm,1)) 1497d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscSequentialPhaseBegin,(void),(PETSC_COMM_WORLD,1)) 1498d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSequentialPhaseEnd(MPI_Comm,PetscMPIInt); 1499d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscSequentialPhaseEnd,(MPI_Comm comm),(comm,1)) 1500d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscSequentialPhaseEnd,(void),(PETSC_COMM_WORLD,1)) 1501d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBarrier(PetscObject); 1502d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMPIDump(FILE*); 1503d382aafbSBarry Smith 1504d382aafbSBarry Smith #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE) 1505d382aafbSBarry Smith /* 1506d382aafbSBarry Smith Defines basic graphics available from PETSc. 1507d382aafbSBarry Smith */ 1508d382aafbSBarry Smith #include "petscdraw.h" 1509d382aafbSBarry Smith 1510d382aafbSBarry Smith /* 1511d382aafbSBarry Smith Defines the base data structures for all PETSc objects 1512d382aafbSBarry Smith */ 1513d382aafbSBarry Smith #include "private/petscimpl.h" 1514d382aafbSBarry Smith /* 1515d382aafbSBarry Smith Defines PETSc profiling. 1516d382aafbSBarry Smith */ 1517d382aafbSBarry Smith #include "petsclog.h" 1518d382aafbSBarry Smith 15196c7e564aSBarry Smith 1520d382aafbSBarry Smith /* 1521d382aafbSBarry Smith For locking, unlocking and destroying AMS memories associated with 1522d382aafbSBarry Smith PETSc objects. Not currently used. 1523d382aafbSBarry Smith */ 1524d382aafbSBarry Smith #define PetscPublishAll(v) 0 1525d382aafbSBarry Smith #define PetscObjectTakeAccess(obj) 0 1526d382aafbSBarry Smith #define PetscObjectGrantAccess(obj) 0 1527d382aafbSBarry Smith #define PetscObjectDepublish(obj) 0 1528d382aafbSBarry Smith 1529d382aafbSBarry Smith /* 1530d382aafbSBarry Smith Simple PETSc parallel IO for ASCII printing 1531d382aafbSBarry Smith */ 1532d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFixFilename(const char[],char[]); 1533d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFOpen(MPI_Comm,const char[],const char[],FILE**); 1534d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFClose(MPI_Comm,FILE*); 1535d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 1536d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 1537d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSNPrintf(char*,size_t,const char [],...); 1538d382aafbSBarry Smith 1539d382aafbSBarry Smith /* These are used internally by PETSc ASCII IO routines*/ 1540d382aafbSBarry Smith #include <stdarg.h> 1541d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscVSNPrintf(char*,size_t,const char[],int*,va_list); 1542d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT (*PetscVFPrintf)(FILE*,const char[],va_list); 1543d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscVFPrintfDefault(FILE*,const char[],va_list); 1544d382aafbSBarry Smith 1545d382aafbSBarry Smith /*MC 1546d382aafbSBarry Smith PetscErrorPrintf - Prints error messages. 1547d382aafbSBarry Smith 1548d382aafbSBarry Smith Not Collective 1549d382aafbSBarry Smith 1550d382aafbSBarry Smith Synopsis: 1551d382aafbSBarry Smith PetscErrorCode (*PetscErrorPrintf)(const char format[],...); 1552d382aafbSBarry Smith 1553d382aafbSBarry Smith Input Parameters: 1554d382aafbSBarry Smith . format - the usual printf() format string 1555d382aafbSBarry Smith 1556d382aafbSBarry Smith Options Database Keys: 1557d382aafbSBarry Smith + -error_output_stdout - cause error messages to be printed to stdout instead of the 1558d382aafbSBarry Smith (default) stderr 1559d382aafbSBarry Smith - -error_output_none to turn off all printing of error messages (does not change the way the 1560d382aafbSBarry Smith error is handled.) 1561d382aafbSBarry Smith 1562d382aafbSBarry Smith Notes: Use 1563d382aafbSBarry Smith $ PetscErrorPrintf = PetscErrorPrintfNone; to turn off all printing of error messages (does not change the way the 1564d382aafbSBarry Smith $ error is handled.) and 1565d382aafbSBarry Smith $ PetscErrorPrintf = PetscErrorPrintfDefault; to turn it back on 1566d382aafbSBarry Smith 1567d382aafbSBarry Smith Use 1568d382aafbSBarry Smith PETSC_STDERR = FILE* obtained from a file open etc. to have stderr printed to the file. 1569d382aafbSBarry Smith PETSC_STDOUT = FILE* obtained from a file open etc. to have stdout printed to the file. 1570d382aafbSBarry Smith 1571d382aafbSBarry Smith Use 1572d382aafbSBarry Smith PetscPushErrorHandler() to provide your own error handler that determines what kind of messages to print 1573d382aafbSBarry Smith 1574d382aafbSBarry Smith Level: developer 1575d382aafbSBarry Smith 1576d382aafbSBarry Smith Fortran Note: 1577d382aafbSBarry Smith This routine is not supported in Fortran. 1578d382aafbSBarry Smith 1579d382aafbSBarry Smith Concepts: error messages^printing 1580d382aafbSBarry Smith Concepts: printing^error messages 1581d382aafbSBarry Smith 1582d382aafbSBarry Smith .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscHelpPrintf(), PetscPrintf(), PetscErrorHandlerPush() 1583d382aafbSBarry Smith M*/ 1584d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT PetscErrorCode (*PetscErrorPrintf)(const char[],...); 1585d382aafbSBarry Smith 1586d382aafbSBarry Smith /*MC 1587d382aafbSBarry Smith PetscHelpPrintf - Prints help messages. 1588d382aafbSBarry Smith 1589d382aafbSBarry Smith Not Collective 1590d382aafbSBarry Smith 1591d382aafbSBarry Smith Synopsis: 1592d382aafbSBarry Smith PetscErrorCode (*PetscHelpPrintf)(const char format[],...); 1593d382aafbSBarry Smith 1594d382aafbSBarry Smith Input Parameters: 1595d382aafbSBarry Smith . format - the usual printf() format string 1596d382aafbSBarry Smith 1597d382aafbSBarry Smith Level: developer 1598d382aafbSBarry Smith 1599d382aafbSBarry Smith Fortran Note: 1600d382aafbSBarry Smith This routine is not supported in Fortran. 1601d382aafbSBarry Smith 1602d382aafbSBarry Smith Concepts: help messages^printing 1603d382aafbSBarry Smith Concepts: printing^help messages 1604d382aafbSBarry Smith 1605d382aafbSBarry Smith .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscErrorPrintf() 1606d382aafbSBarry Smith M*/ 1607d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT PetscErrorCode (*PetscHelpPrintf)(MPI_Comm,const char[],...); 1608d382aafbSBarry Smith 1609d382aafbSBarry Smith EXTERN PetscErrorCode PetscErrorPrintfDefault(const char [],...); 1610d382aafbSBarry Smith EXTERN PetscErrorCode PetscErrorPrintfNone(const char [],...); 1611d382aafbSBarry Smith EXTERN PetscErrorCode PetscHelpPrintfDefault(MPI_Comm,const char [],...); 1612d382aafbSBarry Smith 1613d382aafbSBarry Smith #if defined(PETSC_HAVE_POPEN) 1614d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPOpen(MPI_Comm,const char[],const char[],const char[],FILE **); 1615d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPClose(MPI_Comm,FILE*); 1616d382aafbSBarry Smith #endif 1617d382aafbSBarry Smith 1618d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 1619d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 1620d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSynchronizedFlush(MPI_Comm); 1621d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSynchronizedFGets(MPI_Comm,FILE*,size_t,char[]); 1622d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStartMatlab(MPI_Comm,const char[],const char[],FILE**); 1623d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStartJava(MPI_Comm,const char[],const char[],FILE**); 1624d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetPetscDir(const char*[]); 1625d382aafbSBarry Smith 1626d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPopUpSelect(MPI_Comm,const char*,const char*,int,const char**,int*); 1627d382aafbSBarry Smith 1628d382aafbSBarry Smith /*S 1629d382aafbSBarry Smith PetscContainer - Simple PETSc object that contains a pointer to any required data 1630d382aafbSBarry Smith 1631d382aafbSBarry Smith Level: advanced 1632d382aafbSBarry Smith 1633d382aafbSBarry Smith .seealso: PetscObject, PetscContainerCreate() 1634d382aafbSBarry Smith S*/ 1635d382aafbSBarry Smith extern PetscCookie PETSC_DLLEXPORT PETSC_CONTAINER_COOKIE; 1636d382aafbSBarry Smith typedef struct _p_PetscContainer* PetscContainer; 1637d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerGetPointer(PetscContainer,void **); 1638d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerSetPointer(PetscContainer,void *); 1639d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerDestroy(PetscContainer); 1640d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerCreate(MPI_Comm,PetscContainer *); 1641d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerSetUserDestroy(PetscContainer, PetscErrorCode (*)(void*)); 1642d382aafbSBarry Smith 1643d382aafbSBarry Smith /* 1644d382aafbSBarry Smith For use in debuggers 1645d382aafbSBarry Smith */ 1646d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscMPIInt PetscGlobalRank; 1647d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscMPIInt PetscGlobalSize; 1648d382aafbSBarry Smith 1649d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscIntView(PetscInt,const PetscInt[],PetscViewer); 1650d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRealView(PetscInt,const PetscReal[],PetscViewer); 1651d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscScalarView(PetscInt,const PetscScalar[],PetscViewer); 1652d382aafbSBarry Smith 1653d382aafbSBarry Smith #if defined(PETSC_HAVE_MEMORY_H) 1654d382aafbSBarry Smith #include <memory.h> 1655d382aafbSBarry Smith #endif 1656d382aafbSBarry Smith #if defined(PETSC_HAVE_STDLIB_H) 1657d382aafbSBarry Smith #include <stdlib.h> 1658d382aafbSBarry Smith #endif 1659d382aafbSBarry Smith #if defined(PETSC_HAVE_STRINGS_H) 1660d382aafbSBarry Smith #include <strings.h> 1661d382aafbSBarry Smith #endif 1662d382aafbSBarry Smith #if defined(PETSC_HAVE_STRING_H) 1663d382aafbSBarry Smith #include <string.h> 1664d382aafbSBarry Smith #endif 16656c7e564aSBarry Smith 16666c7e564aSBarry Smith 1667d382aafbSBarry Smith #if defined(PETSC_HAVE_XMMINTRIN_H) 1668d382aafbSBarry Smith #include <xmmintrin.h> 1669d382aafbSBarry Smith #endif 1670d382aafbSBarry Smith #if defined(PETSC_HAVE_STDINT_H) 1671d382aafbSBarry Smith #include <stdint.h> 1672d382aafbSBarry Smith #endif 1673d382aafbSBarry Smith 1674d382aafbSBarry Smith /*@C 1675d382aafbSBarry Smith PetscMemcpy - Copies n bytes, beginning at location b, to the space 1676d382aafbSBarry Smith beginning at location a. The two memory regions CANNOT overlap, use 1677d382aafbSBarry Smith PetscMemmove() in that case. 1678d382aafbSBarry Smith 1679d382aafbSBarry Smith Not Collective 1680d382aafbSBarry Smith 1681d382aafbSBarry Smith Input Parameters: 1682d382aafbSBarry Smith + b - pointer to initial memory space 1683d382aafbSBarry Smith - n - length (in bytes) of space to copy 1684d382aafbSBarry Smith 1685d382aafbSBarry Smith Output Parameter: 1686d382aafbSBarry Smith . a - pointer to copy space 1687d382aafbSBarry Smith 1688d382aafbSBarry Smith Level: intermediate 1689d382aafbSBarry Smith 1690d382aafbSBarry Smith Compile Option: 1691d382aafbSBarry Smith PETSC_PREFER_DCOPY_FOR_MEMCPY will cause the BLAS dcopy() routine to be used 1692d382aafbSBarry Smith for memory copies on double precision values. 1693d382aafbSBarry Smith PETSC_PREFER_COPY_FOR_MEMCPY will cause C code to be used 1694d382aafbSBarry Smith for memory copies on double precision values. 1695d382aafbSBarry Smith PETSC_PREFER_FORTRAN_FORMEMCPY will cause Fortran code to be used 1696d382aafbSBarry Smith for memory copies on double precision values. 1697d382aafbSBarry Smith 1698d382aafbSBarry Smith Note: 1699d382aafbSBarry Smith This routine is analogous to memcpy(). 1700d382aafbSBarry Smith 1701d382aafbSBarry Smith Concepts: memory^copying 1702d382aafbSBarry Smith Concepts: copying^memory 1703d382aafbSBarry Smith 1704d382aafbSBarry Smith .seealso: PetscMemmove() 1705d382aafbSBarry Smith 1706d382aafbSBarry Smith @*/ 1707d382aafbSBarry Smith PETSC_STATIC_INLINE PetscErrorCode PETSC_DLLEXPORT PetscMemcpy(void *a,const void *b,size_t n) 1708d382aafbSBarry Smith { 1709d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1710d382aafbSBarry Smith unsigned long al = (unsigned long) a,bl = (unsigned long) b; 1711d382aafbSBarry Smith unsigned long nl = (unsigned long) n; 1712d382aafbSBarry Smith if (n > 0 && !b) SETERRQ(PETSC_ERR_ARG_NULL,"Trying to copy from a null pointer"); 1713d382aafbSBarry Smith if (n > 0 && !a) SETERRQ(PETSC_ERR_ARG_NULL,"Trying to copy to a null pointer"); 1714d382aafbSBarry Smith #endif 1715d382aafbSBarry Smith PetscFunctionBegin; 1716d382aafbSBarry Smith if (a != b) { 1717d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1718d382aafbSBarry Smith if ((al > bl && (al - bl) < nl) || (bl - al) < nl) { 1719d382aafbSBarry Smith SETERRQ3(PETSC_ERR_ARG_INCOMP,"Memory regions overlap: either use PetscMemmov()\n\ 1720d382aafbSBarry Smith or make sure your copy regions and lengths are correct. \n\ 1721d382aafbSBarry Smith Length (bytes) %ld first address %ld second address %ld",nl,al,bl); 1722d382aafbSBarry Smith } 1723d382aafbSBarry Smith #endif 1724d382aafbSBarry Smith #if (defined(PETSC_PREFER_DCOPY_FOR_MEMCPY) || defined(PETSC_PREFER_COPY_FOR_MEMCPY) || defined(PETSC_PREFER_FORTRAN_FORMEMCPY)) 1725d382aafbSBarry Smith if (!(((long) a) % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) { 1726d382aafbSBarry Smith size_t len = n/sizeof(PetscScalar); 1727d382aafbSBarry Smith #if defined(PETSC_PREFER_DCOPY_FOR_MEMCPY) 1728d382aafbSBarry Smith PetscBLASInt one = 1,blen = PetscBLASIntCast(len); 1729d382aafbSBarry Smith BLAScopy_(&blen,(PetscScalar *)b,&one,(PetscScalar *)a,&one); 1730d382aafbSBarry Smith #elif defined(PETSC_PREFER_FORTRAN_FORMEMCPY) 1731d382aafbSBarry Smith fortrancopy_(&len,(PetscScalar*)b,(PetscScalar*)a); 1732d382aafbSBarry Smith #else 1733d382aafbSBarry Smith size_t i; 1734d382aafbSBarry Smith PetscScalar *x = (PetscScalar*)b, *y = (PetscScalar*)a; 1735d382aafbSBarry Smith for (i=0; i<len; i++) y[i] = x[i]; 1736d382aafbSBarry Smith #endif 1737d382aafbSBarry Smith } else { 1738d382aafbSBarry Smith memcpy((char*)(a),(char*)(b),n); 1739d382aafbSBarry Smith } 1740d382aafbSBarry Smith #elif defined(PETSC_HAVE__INTEL_FAST_MEMCPY) 1741d382aafbSBarry Smith _intel_fast_memcpy((char*)(a),(char*)(b),n); 1742d382aafbSBarry Smith #else 1743d382aafbSBarry Smith memcpy((char*)(a),(char*)(b),n); 1744d382aafbSBarry Smith #endif 1745d382aafbSBarry Smith } 1746d382aafbSBarry Smith PetscFunctionReturn(0); 1747d382aafbSBarry Smith } 1748d382aafbSBarry Smith 1749d382aafbSBarry Smith /*@C 1750d382aafbSBarry Smith PetscMemzero - Zeros the specified memory. 1751d382aafbSBarry Smith 1752d382aafbSBarry Smith Not Collective 1753d382aafbSBarry Smith 1754d382aafbSBarry Smith Input Parameters: 1755d382aafbSBarry Smith + a - pointer to beginning memory location 1756d382aafbSBarry Smith - n - length (in bytes) of memory to initialize 1757d382aafbSBarry Smith 1758d382aafbSBarry Smith Level: intermediate 1759d382aafbSBarry Smith 1760d382aafbSBarry Smith Compile Option: 1761d382aafbSBarry Smith PETSC_PREFER_BZERO - on certain machines (the IBM RS6000) the bzero() routine happens 1762d382aafbSBarry Smith to be faster than the memset() routine. This flag causes the bzero() routine to be used. 1763d382aafbSBarry Smith 1764d382aafbSBarry Smith Concepts: memory^zeroing 1765d382aafbSBarry Smith Concepts: zeroing^memory 1766d382aafbSBarry Smith 1767d382aafbSBarry Smith .seealso: PetscMemcpy() 1768d382aafbSBarry Smith @*/ 1769d382aafbSBarry Smith PETSC_STATIC_INLINE PetscErrorCode PETSC_DLLEXPORT PetscMemzero(void *a,size_t n) 1770d382aafbSBarry Smith { 1771d382aafbSBarry Smith if (n > 0) { 1772d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1773d382aafbSBarry Smith if (!a) SETERRQ(PETSC_ERR_ARG_NULL,"Trying to zero at a null pointer"); 1774d382aafbSBarry Smith #endif 1775d382aafbSBarry Smith #if defined(PETSC_PREFER_ZERO_FOR_MEMZERO) 1776d382aafbSBarry Smith if (!(((long) a) % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) { 1777d382aafbSBarry Smith size_t i,len = n/sizeof(PetscScalar); 1778d382aafbSBarry Smith PetscScalar *x = (PetscScalar*)a; 1779d382aafbSBarry Smith for (i=0; i<len; i++) x[i] = 0.0; 1780d382aafbSBarry Smith } else { 1781d382aafbSBarry Smith #elif defined(PETSC_PREFER_FORTRAN_FOR_MEMZERO) 1782d382aafbSBarry Smith if (!(((long) a) % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) { 1783d382aafbSBarry Smith PetscInt len = n/sizeof(PetscScalar); 1784d382aafbSBarry Smith fortranzero_(&len,(PetscScalar*)a); 1785d382aafbSBarry Smith } else { 1786d382aafbSBarry Smith #endif 1787d382aafbSBarry Smith #if defined(PETSC_PREFER_BZERO) 1788d382aafbSBarry Smith bzero((char *)a,n); 1789d382aafbSBarry Smith #elif defined (PETSC_HAVE__INTEL_FAST_MEMSET) 1790d382aafbSBarry Smith _intel_fast_memset((char*)a,0,n); 1791d382aafbSBarry Smith #else 1792d382aafbSBarry Smith memset((char*)a,0,n); 1793d382aafbSBarry Smith #endif 1794d382aafbSBarry Smith #if defined(PETSC_PREFER_ZERO_FOR_MEMZERO) || defined(PETSC_PREFER_FORTRAN_FOR_MEMZERO) 1795d382aafbSBarry Smith } 1796d382aafbSBarry Smith #endif 1797d382aafbSBarry Smith } 1798d382aafbSBarry Smith return 0; 1799d382aafbSBarry Smith } 1800d382aafbSBarry Smith 1801d382aafbSBarry Smith /*MC 1802d382aafbSBarry Smith PetscPrefetchBlock - Prefetches a block of memory 1803d382aafbSBarry Smith 1804d382aafbSBarry Smith Not Collective 1805d382aafbSBarry Smith 1806d382aafbSBarry Smith Input Parameters: 1807d382aafbSBarry Smith + a - pointer to first element to fetch (any type but usually PetscInt or PetscScalar) 1808d382aafbSBarry Smith . n - number of elements to fetch 1809d382aafbSBarry Smith . rw - 1 if the memory will be written to, otherwise 0 (ignored by many processors) 1810d382aafbSBarry Smith - t - temporal locality (0,1,2,3), see note 1811d382aafbSBarry Smith 1812d382aafbSBarry Smith Level: developer 1813d382aafbSBarry Smith 1814d382aafbSBarry Smith Synopsis: 1815d382aafbSBarry Smith void PetscPrefetchBlock(const anytype *a,size_t n,int rw,int t) 1816d382aafbSBarry Smith 1817d382aafbSBarry Smith Notes: 1818d382aafbSBarry Smith The last two arguments (rw and t) must be compile-time constants. 1819d382aafbSBarry Smith 1820d382aafbSBarry Smith There are four levels of temporal locality (not all architectures distinguish) 1821d382aafbSBarry Smith + 0 - Non-temporal. Prefetches directly to L1, evicts to memory (skips higher level cache unless it was already there when prefetched). 1822d382aafbSBarry Smith . 1 - Temporal with respect to high-level cache only. Only prefetches to high-level cache (not L1), kept at high levels after eviction from L1. 1823d382aafbSBarry Smith . 2 - Same as 1, but keep in mid-level cache. (On most systems, 1 and 2 are equivalent.) 1824d382aafbSBarry Smith - 3 - Fetch to all levels of cache and evict to the closest level. Use this when the memory will be reused regularly despite necessary eviction from L1. 1825d382aafbSBarry Smith 1826d382aafbSBarry Smith This function does nothing on architectures that do not support prefetch and never errors (even if passed an invalid 1827d382aafbSBarry Smith address). 1828d382aafbSBarry Smith 1829d382aafbSBarry Smith Concepts: memory 1830d382aafbSBarry Smith M*/ 1831d382aafbSBarry Smith #define PetscPrefetchBlock(a,n,rw,t) do { \ 1832d382aafbSBarry Smith const char *_p = (const char*)(a),*_end = (const char*)((a)+(n)); \ 1833d382aafbSBarry Smith for ( ; _p < _end; _p += PETSC_LEVEL1_DCACHE_LINESIZE) PETSC_Prefetch(_p,(rw),(t)); \ 1834d382aafbSBarry Smith } while (0) 1835d382aafbSBarry Smith 1836d382aafbSBarry Smith /* 1837d382aafbSBarry Smith Allows accessing Matlab Engine 1838d382aafbSBarry Smith */ 1839d382aafbSBarry Smith #include "petscmatlab.h" 1840d382aafbSBarry Smith 1841d382aafbSBarry Smith /* 1842d382aafbSBarry Smith Determine if some of the kernel computation routines use 1843d382aafbSBarry Smith Fortran (rather than C) for the numerical calculations. On some machines 1844d382aafbSBarry Smith and compilers (like complex numbers) the Fortran version of the routines 1845d382aafbSBarry Smith is faster than the C/C++ versions. The flag --with-fortran-kernels 1846d382aafbSBarry Smith should be used with config/configure.py to turn these on. 1847d382aafbSBarry Smith */ 1848d382aafbSBarry Smith #if defined(PETSC_USE_FORTRAN_KERNELS) 1849d382aafbSBarry Smith 1850d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTCRL) 1851d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTCRL 1852d382aafbSBarry Smith #endif 1853d382aafbSBarry Smith 1854d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTCSRPERM) 1855d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTCSRPERM 1856d382aafbSBarry Smith #endif 1857d382aafbSBarry Smith 1858d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 1859d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 1860d382aafbSBarry Smith #endif 1861d382aafbSBarry Smith 1862d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 1863d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 1864d382aafbSBarry Smith #endif 1865d382aafbSBarry Smith 1866d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM) 1867d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_NORM 1868d382aafbSBarry Smith #endif 1869d382aafbSBarry Smith 1870d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 1871d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MAXPY 1872d382aafbSBarry Smith #endif 1873d382aafbSBarry Smith 1874d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 1875d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 1876d382aafbSBarry Smith #endif 1877d382aafbSBarry Smith 1878d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 1879d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 1880d382aafbSBarry Smith #endif 1881d382aafbSBarry Smith 1882d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 1883d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 1884d382aafbSBarry Smith #endif 1885d382aafbSBarry Smith 1886d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 1887d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 1888d382aafbSBarry Smith #endif 1889d382aafbSBarry Smith 1890d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 1891d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MDOT 1892d382aafbSBarry Smith #endif 1893d382aafbSBarry Smith 1894d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 1895d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 1896d382aafbSBarry Smith #endif 1897d382aafbSBarry Smith 1898d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX) 1899d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_AYPX 1900d382aafbSBarry Smith #endif 1901d382aafbSBarry Smith 1902d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY) 1903d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_WAXPY 1904d382aafbSBarry Smith #endif 1905d382aafbSBarry Smith 1906d382aafbSBarry Smith #endif 1907d382aafbSBarry Smith 1908d382aafbSBarry Smith /* 1909d382aafbSBarry Smith Macros for indicating code that should be compiled with a C interface, 1910d382aafbSBarry Smith rather than a C++ interface. Any routines that are dynamically loaded 1911d382aafbSBarry Smith (such as the PCCreate_XXX() routines) must be wrapped so that the name 1912d382aafbSBarry Smith mangler does not change the functions symbol name. This just hides the 1913d382aafbSBarry Smith ugly extern "C" {} wrappers. 1914d382aafbSBarry Smith */ 1915d382aafbSBarry Smith #if defined(__cplusplus) 1916d382aafbSBarry Smith #define EXTERN_C_BEGIN extern "C" { 1917d382aafbSBarry Smith #define EXTERN_C_END } 1918d382aafbSBarry Smith #else 1919d382aafbSBarry Smith #define EXTERN_C_BEGIN 1920d382aafbSBarry Smith #define EXTERN_C_END 1921d382aafbSBarry Smith #endif 1922d382aafbSBarry Smith 1923d382aafbSBarry Smith /* --------------------------------------------------------------------*/ 1924d382aafbSBarry Smith 1925d382aafbSBarry Smith /*MC 1926d382aafbSBarry Smith MPI_Comm - the basic object used by MPI to determine which processes are involved in a 1927d382aafbSBarry Smith communication 1928d382aafbSBarry Smith 1929d382aafbSBarry Smith Level: beginner 1930d382aafbSBarry Smith 1931d382aafbSBarry Smith Note: This manual page is a place-holder because MPICH does not have a manual page for MPI_Comm 1932d382aafbSBarry Smith 1933d382aafbSBarry Smith .seealso: PETSC_COMM_WORLD, PETSC_COMM_SELF 1934d382aafbSBarry Smith M*/ 1935d382aafbSBarry Smith 1936d382aafbSBarry Smith /*MC 1937d382aafbSBarry Smith PetscScalar - PETSc type that represents either a double precision real number, a double precision 1938d382aafbSBarry Smith complex number, a single precision real number, a long double or an int - if the code is configured 1939d382aafbSBarry Smith with --with-scalar-type=real,complex --with-precision=single,double,longdouble,int,matsingle 1940d382aafbSBarry Smith 1941d382aafbSBarry Smith 1942d382aafbSBarry Smith Level: beginner 1943d382aafbSBarry Smith 1944d382aafbSBarry Smith .seealso: PetscReal, PassiveReal, PassiveScalar, MPIU_SCALAR, PetscInt 1945d382aafbSBarry Smith M*/ 1946d382aafbSBarry Smith 1947d382aafbSBarry Smith /*MC 1948d382aafbSBarry Smith PetscReal - PETSc type that represents a real number version of PetscScalar 1949d382aafbSBarry Smith 1950d382aafbSBarry Smith Level: beginner 1951d382aafbSBarry Smith 1952d382aafbSBarry Smith .seealso: PetscScalar, PassiveReal, PassiveScalar 1953d382aafbSBarry Smith M*/ 1954d382aafbSBarry Smith 1955d382aafbSBarry Smith /*MC 1956d382aafbSBarry Smith PassiveScalar - PETSc type that represents a PetscScalar 1957d382aafbSBarry Smith Level: beginner 1958d382aafbSBarry Smith 1959d382aafbSBarry Smith This is the same as a PetscScalar except in code that is automatically differentiated it is 1960d382aafbSBarry Smith treated as a constant (not an indendent or dependent variable) 1961d382aafbSBarry Smith 1962d382aafbSBarry Smith .seealso: PetscReal, PassiveReal, PetscScalar 1963d382aafbSBarry Smith M*/ 1964d382aafbSBarry Smith 1965d382aafbSBarry Smith /*MC 1966d382aafbSBarry Smith PassiveReal - PETSc type that represents a PetscReal 1967d382aafbSBarry Smith 1968d382aafbSBarry Smith Level: beginner 1969d382aafbSBarry Smith 1970d382aafbSBarry Smith This is the same as a PetscReal except in code that is automatically differentiated it is 1971d382aafbSBarry Smith treated as a constant (not an indendent or dependent variable) 1972d382aafbSBarry Smith 1973d382aafbSBarry Smith .seealso: PetscScalar, PetscReal, PassiveScalar 1974d382aafbSBarry Smith M*/ 1975d382aafbSBarry Smith 1976d382aafbSBarry Smith /*MC 1977d382aafbSBarry Smith MPIU_SCALAR - MPI datatype corresponding to PetscScalar 1978d382aafbSBarry Smith 1979d382aafbSBarry Smith Level: beginner 1980d382aafbSBarry Smith 1981d382aafbSBarry Smith Note: In MPI calls that require an MPI datatype that matches a PetscScalar or array of PetscScalars 1982d382aafbSBarry Smith pass this value 1983d382aafbSBarry Smith 1984d382aafbSBarry Smith .seealso: PetscReal, PassiveReal, PassiveScalar, PetscScalar, MPIU_INT 1985d382aafbSBarry Smith M*/ 1986d382aafbSBarry Smith 1987d382aafbSBarry Smith #if defined(PETSC_HAVE_MPIIO) 1988d382aafbSBarry Smith #if !defined(PETSC_WORDS_BIGENDIAN) 1989d382aafbSBarry Smith extern PetscErrorCode MPIU_File_write_all(MPI_File,void*,PetscMPIInt,MPI_Datatype,MPI_Status*); 1990d382aafbSBarry Smith extern PetscErrorCode MPIU_File_read_all(MPI_File,void*,PetscMPIInt,MPI_Datatype,MPI_Status*); 1991d382aafbSBarry Smith #else 1992d382aafbSBarry Smith #define MPIU_File_write_all(a,b,c,d,e) MPI_File_write_all(a,b,c,d,e) 1993d382aafbSBarry Smith #define MPIU_File_read_all(a,b,c,d,e) MPI_File_read_all(a,b,c,d,e) 1994d382aafbSBarry Smith #endif 1995d382aafbSBarry Smith #endif 1996d382aafbSBarry Smith 1997d382aafbSBarry Smith /* the following petsc_static_inline require petscerror.h */ 1998d382aafbSBarry Smith 1999d382aafbSBarry Smith /* Limit MPI to 32-bits */ 2000d382aafbSBarry Smith #define PETSC_MPI_INT_MAX 2147483647 2001d382aafbSBarry Smith #define PETSC_MPI_INT_MIN -2147483647 2002d382aafbSBarry Smith /* Limit BLAS to 32-bits */ 2003d382aafbSBarry Smith #define PETSC_BLAS_INT_MAX 2147483647 2004d382aafbSBarry Smith #define PETSC_BLAS_INT_MIN -2147483647 2005d382aafbSBarry Smith /* On 32 bit systems HDF5 is limited by size of integer, because hsize_t is defined as size_t */ 2006d382aafbSBarry Smith #define PETSC_HDF5_INT_MAX 2147483647 2007d382aafbSBarry Smith #define PETSC_HDF5_INT_MIN -2147483647 2008d382aafbSBarry Smith 2009d382aafbSBarry Smith #if defined(PETSC_USE_64BIT_INDICES) 2010d382aafbSBarry Smith #define PetscMPIIntCheck(a) if ((a) > PETSC_MPI_INT_MAX) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Message too long for MPI") 2011d382aafbSBarry Smith #define PetscBLASIntCheck(a) if ((a) > PETSC_BLAS_INT_MAX) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Array too long for BLAS/LAPACK") 2012d382aafbSBarry Smith #define PetscMPIIntCast(a) (a);PetscMPIIntCheck(a) 2013d382aafbSBarry Smith #define PetscBLASIntCast(a) (a);PetscBLASIntCheck(a) 2014d382aafbSBarry Smith 2015d382aafbSBarry Smith #if (PETSC_SIZEOF_SIZE_T == 4) 2016d382aafbSBarry Smith #define PetscHDF5IntCheck(a) if ((a) > PETSC_HDF5_INT_MAX) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Array too long for HDF5") 2017d382aafbSBarry Smith #define PetscHDF5IntCast(a) (a);PetscHDF5IntCheck(a) 2018d382aafbSBarry Smith #else 2019d382aafbSBarry Smith #define PetscHDF5IntCheck(a) 2020d382aafbSBarry Smith #define PetscHDF5IntCast(a) a 2021d382aafbSBarry Smith #endif 2022d382aafbSBarry Smith 2023d382aafbSBarry Smith #else 2024d382aafbSBarry Smith #define PetscMPIIntCheck(a) 2025d382aafbSBarry Smith #define PetscBLASIntCheck(a) 2026d382aafbSBarry Smith #define PetscHDF5IntCheck(a) 2027d382aafbSBarry Smith #define PetscMPIIntCast(a) a 2028d382aafbSBarry Smith #define PetscBLASIntCast(a) a 2029d382aafbSBarry Smith #define PetscHDF5IntCast(a) a 2030d382aafbSBarry Smith #endif 2031d382aafbSBarry Smith 2032d382aafbSBarry Smith 2033d382aafbSBarry Smith /* 2034d382aafbSBarry Smith The IBM include files define hz, here we hide it so that it may be used 2035d382aafbSBarry Smith as a regular user variable. 2036d382aafbSBarry Smith */ 2037d382aafbSBarry Smith #if defined(hz) 2038d382aafbSBarry Smith #undef hz 2039d382aafbSBarry Smith #endif 2040d382aafbSBarry Smith 2041d382aafbSBarry Smith /* For arrays that contain filenames or paths */ 2042d382aafbSBarry Smith 2043d382aafbSBarry Smith 2044d382aafbSBarry Smith #if defined(PETSC_HAVE_LIMITS_H) 2045d382aafbSBarry Smith #include <limits.h> 2046d382aafbSBarry Smith #endif 2047d382aafbSBarry Smith #if defined(PETSC_HAVE_SYS_PARAM_H) 2048d382aafbSBarry Smith #include <sys/param.h> 2049d382aafbSBarry Smith #endif 2050d382aafbSBarry Smith #if defined(PETSC_HAVE_SYS_TYPES_H) 2051d382aafbSBarry Smith #include <sys/types.h> 2052d382aafbSBarry Smith #endif 2053d382aafbSBarry Smith #if defined(MAXPATHLEN) 2054d382aafbSBarry Smith # define PETSC_MAX_PATH_LEN MAXPATHLEN 2055d382aafbSBarry Smith #elif defined(MAX_PATH) 2056d382aafbSBarry Smith # define PETSC_MAX_PATH_LEN MAX_PATH 2057d382aafbSBarry Smith #elif defined(_MAX_PATH) 2058d382aafbSBarry Smith # define PETSC_MAX_PATH_LEN _MAX_PATH 2059d382aafbSBarry Smith #else 2060d382aafbSBarry Smith # define PETSC_MAX_PATH_LEN 4096 2061d382aafbSBarry Smith #endif 2062d382aafbSBarry Smith 2063d382aafbSBarry Smith /* Special support for C++ */ 2064d382aafbSBarry Smith #include "petscsys.hh" 20656c7e564aSBarry Smith 2066d382aafbSBarry Smith 2067d382aafbSBarry Smith /*MC 2068d382aafbSBarry Smith 2069d382aafbSBarry Smith UsingFortran - Fortran can be used with PETSc in four distinct approaches 2070d382aafbSBarry Smith 2071d382aafbSBarry Smith $ 1) classic Fortran 77 style 2072d382aafbSBarry Smith $#include "petscXXX.h" to work with material from the XXX component of PETSc 2073d382aafbSBarry Smith $ XXX variablename 2074d382aafbSBarry Smith $ You cannot use this approach if you wish to use the Fortran 90 specific PETSc routines 2075d382aafbSBarry Smith $ which end in F90; such as VecGetArrayF90() 2076d382aafbSBarry Smith $ 2077d382aafbSBarry Smith $ 2) classic Fortran 90 style 2078d382aafbSBarry Smith $#include "petscXXX.h" 2079d382aafbSBarry Smith $#include "petscXXX.h90" to work with material from the XXX component of PETSc 2080d382aafbSBarry Smith $ XXX variablename 2081d382aafbSBarry Smith $ 2082d382aafbSBarry Smith $ 3) Using Fortran modules 2083d382aafbSBarry Smith $#include "petscXXXdef.h" 2084d382aafbSBarry Smith $ use petscXXXX 2085d382aafbSBarry Smith $ XXX variablename 2086d382aafbSBarry Smith $ 2087d382aafbSBarry Smith $ 4) Use Fortran modules and Fortran data types for PETSc types 2088d382aafbSBarry Smith $#include "petscXXXdef.h" 2089d382aafbSBarry Smith $ use petscXXXX 2090d382aafbSBarry Smith $ type(XXX) variablename 2091d382aafbSBarry Smith $ To use this approach you must config/configure.py PETSc with the additional 2092d382aafbSBarry Smith $ option --with-fortran-datatypes You cannot use the type(XXX) declaration approach without using Fortran modules 2093d382aafbSBarry Smith 2094d382aafbSBarry Smith Finally if you absolutely do not want to use any #include you can use either 2095d382aafbSBarry Smith 2096d382aafbSBarry Smith $ 3a) skip the #include BUT you cannot use any PETSc data type names like Vec, Mat, PetscInt, PetscErrorCode etc 2097d382aafbSBarry Smith $ and you must declare the variables as integer, for example 2098d382aafbSBarry Smith $ integer variablename 2099d382aafbSBarry Smith $ 2100d382aafbSBarry Smith $ 4a) skip the #include, you use the object types like type(Vec) type(Mat) but cannot use the data type 2101d382aafbSBarry Smith $ names like PetscErrorCode, PetscInt etc. again for those you must use integer 2102d382aafbSBarry Smith 2103d382aafbSBarry Smith We recommend either 2 or 3. Approaches 2 and 3 provide type checking for most PETSc function calls; 4 has type checking 2104d382aafbSBarry Smith for only a few PETSc functions. 2105d382aafbSBarry Smith 2106d382aafbSBarry Smith Fortran type checking with interfaces is strick, this means you cannot pass a scalar value when an array value 2107d382aafbSBarry Smith is expected (even though it is legal Fortran). For example when setting a single value in a matrix with MatSetValues() 2108d382aafbSBarry Smith you cannot have something like 2109d382aafbSBarry Smith $ PetscInt row,col 2110d382aafbSBarry Smith $ PetscScalar val 2111d382aafbSBarry Smith $ ... 2112d382aafbSBarry Smith $ call MatSetValues(mat,1,row,1,col,val,INSERT_VALUES,ierr) 2113d382aafbSBarry Smith You must instead have 2114d382aafbSBarry Smith $ PetscInt row(1),col(1) 2115d382aafbSBarry Smith $ PetscScalar val(1) 2116d382aafbSBarry Smith $ ... 2117d382aafbSBarry Smith $ call MatSetValues(mat,1,row,1,col,val,INSERT_VALUES,ierr) 2118d382aafbSBarry Smith 2119d382aafbSBarry Smith 2120d382aafbSBarry Smith See the example src/vec/vec/examples/tutorials/ex20f90.F90 for an example that can use all four approaches 2121d382aafbSBarry Smith 2122d382aafbSBarry Smith Developer Notes: The finclude/petscXXXdef.h contain all the #defines (would be typedefs in C code) these 2123d382aafbSBarry Smith automatically include their predecessors; for example finclude/petscvecdef.h includes finclude/petscisdef.h 2124d382aafbSBarry Smith 2125d382aafbSBarry Smith The finclude/petscXXXX.h contain all the parameter statements for that package. These automatically include 2126d382aafbSBarry Smith their finclude/petscXXXdef.h file but DO NOT automatically include their predecessors; for example 2127d382aafbSBarry Smith finclude/petscvec.h does NOT automatically include finclude/petscis.h 2128d382aafbSBarry Smith 2129d382aafbSBarry Smith The finclude/ftn-custom/petscXXXdef.h90 are not intended to be used directly in code, they define the 2130d382aafbSBarry Smith Fortran data type type(XXX) (for example type(Vec)) when PETSc is config/configure.py with the --with-fortran-datatypes option. 2131d382aafbSBarry Smith 2132d382aafbSBarry Smith The finclude/ftn-custom/petscXXX.h90 (not included directly by code) contain interface definitions for 2133d382aafbSBarry Smith the PETSc Fortran stubs that have different bindings then their C version (for example VecGetArrayF90). 2134d382aafbSBarry Smith 2135d382aafbSBarry Smith The finclude/ftn-auto/petscXXX.h90 (not included directly by code) contain interface definitions generated 2136d382aafbSBarry Smith automatically by "make allfortranstubs". 2137d382aafbSBarry Smith 2138d382aafbSBarry Smith The finclude/petscXXX.h90 includes the custom finclude/ftn-custom/petscXXX.h90 and if config/configure.py 2139d382aafbSBarry Smith was run with --with-fortran-interfaces it also includes the finclude/ftn-auto/petscXXX.h90 These DO NOT automatically 2140d382aafbSBarry Smith include their predecessors 2141d382aafbSBarry Smith 2142d382aafbSBarry Smith Level: beginner 2143d382aafbSBarry Smith 2144d382aafbSBarry Smith M*/ 2145d382aafbSBarry Smith 2146d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetArchType(char[],size_t); 2147d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetHostName(char[],size_t); 2148d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetUserName(char[],size_t); 2149d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetProgramName(char[],size_t); 2150d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetProgramName(const char[]); 2151d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetDate(char[],size_t); 2152d382aafbSBarry Smith 2153d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortInt(PetscInt,PetscInt[]); 2154d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortIntWithPermutation(PetscInt,const PetscInt[],PetscInt[]); 2155d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortStrWithPermutation(PetscInt,const char*[],PetscInt[]); 2156d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortIntWithArray(PetscInt,PetscInt[],PetscInt[]); 2157d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortMPIIntWithArray(PetscMPIInt,PetscMPIInt[],PetscMPIInt[]); 2158d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortIntWithScalarArray(PetscInt,PetscInt[],PetscScalar[]); 2159d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortReal(PetscInt,PetscReal[]); 2160d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortRealWithPermutation(PetscInt,const PetscReal[],PetscInt[]); 2161d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortSplit(PetscInt,PetscInt,PetscScalar[],PetscInt[]); 2162d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortSplitReal(PetscInt,PetscInt,PetscReal[],PetscInt[]); 2163d382aafbSBarry Smith 2164d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDisplay(void); 2165d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetDisplay(char[],size_t); 2166d382aafbSBarry Smith 2167d382aafbSBarry Smith /*E 2168d382aafbSBarry Smith PetscRandomType - String with the name of a PETSc randomizer 2169d382aafbSBarry Smith with an optional dynamic library name, for example 2170d382aafbSBarry Smith http://www.mcs.anl.gov/petsc/lib.a:myrandcreate() 2171d382aafbSBarry Smith 2172d382aafbSBarry Smith Level: beginner 2173d382aafbSBarry Smith 2174d382aafbSBarry Smith Notes: to use the SPRNG you must have config/configure.py PETSc 2175d382aafbSBarry Smith with the option --download-sprng 2176d382aafbSBarry Smith 2177d382aafbSBarry Smith .seealso: PetscRandomSetType(), PetscRandom 2178d382aafbSBarry Smith E*/ 2179d382aafbSBarry Smith #define PetscRandomType char* 2180d382aafbSBarry Smith #define PETSCRAND "rand" 2181d382aafbSBarry Smith #define PETSCRAND48 "rand48" 2182d382aafbSBarry Smith #define PETSCSPRNG "sprng" 2183d382aafbSBarry Smith 2184d382aafbSBarry Smith /* Logging support */ 2185d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscCookie PETSC_RANDOM_COOKIE; 2186d382aafbSBarry Smith 2187d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomInitializePackage(const char[]); 2188d382aafbSBarry Smith 2189d382aafbSBarry Smith /*S 2190d382aafbSBarry Smith PetscRandom - Abstract PETSc object that manages generating random numbers 2191d382aafbSBarry Smith 2192d382aafbSBarry Smith Level: intermediate 2193d382aafbSBarry Smith 2194d382aafbSBarry Smith Concepts: random numbers 2195d382aafbSBarry Smith 2196d382aafbSBarry Smith .seealso: PetscRandomCreate(), PetscRandomGetValue(), PetscRandomType 2197d382aafbSBarry Smith S*/ 2198d382aafbSBarry Smith typedef struct _p_PetscRandom* PetscRandom; 2199d382aafbSBarry Smith 2200d382aafbSBarry Smith /* Dynamic creation and loading functions */ 2201d382aafbSBarry Smith extern PetscFList PetscRandomList; 2202d382aafbSBarry Smith extern PetscTruth PetscRandomRegisterAllCalled; 2203d382aafbSBarry Smith 2204d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomRegisterAll(const char []); 2205d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomRegister(const char[],const char[],const char[],PetscErrorCode (*)(PetscRandom)); 2206d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomRegisterDestroy(void); 2207d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSetType(PetscRandom, const PetscRandomType); 2208d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSetFromOptions(PetscRandom); 2209d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetType(PetscRandom, const PetscRandomType*); 2210d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomViewFromOptions(PetscRandom,char*); 2211d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomView(PetscRandom,PetscViewer); 2212d382aafbSBarry Smith 2213d382aafbSBarry Smith /*MC 2214d382aafbSBarry Smith PetscRandomRegisterDynamic - Adds a new PetscRandom component implementation 2215d382aafbSBarry Smith 2216d382aafbSBarry Smith Synopsis: 2217d382aafbSBarry Smith PetscErrorCode PetscRandomRegisterDynamic(char *name, char *path, char *func_name, PetscErrorCode (*create_func)(PetscRandom)) 2218d382aafbSBarry Smith 2219d382aafbSBarry Smith Not Collective 2220d382aafbSBarry Smith 2221d382aafbSBarry Smith Input Parameters: 2222d382aafbSBarry Smith + name - The name of a new user-defined creation routine 2223d382aafbSBarry Smith . path - The path (either absolute or relative) of the library containing this routine 2224d382aafbSBarry Smith . func_name - The name of routine to create method context 2225d382aafbSBarry Smith - create_func - The creation routine itself 2226d382aafbSBarry Smith 2227d382aafbSBarry Smith Notes: 2228d382aafbSBarry Smith PetscRandomRegisterDynamic() may be called multiple times to add several user-defined randome number generators 2229d382aafbSBarry Smith 2230d382aafbSBarry Smith If dynamic libraries are used, then the fourth input argument (routine_create) is ignored. 2231d382aafbSBarry Smith 2232d382aafbSBarry Smith Sample usage: 2233d382aafbSBarry Smith .vb 2234d382aafbSBarry Smith PetscRandomRegisterDynamic("my_rand","/home/username/my_lib/lib/libO/solaris/libmy.a", "MyPetscRandomtorCreate", MyPetscRandomtorCreate); 2235d382aafbSBarry Smith .ve 2236d382aafbSBarry Smith 2237d382aafbSBarry Smith Then, your random type can be chosen with the procedural interface via 2238d382aafbSBarry Smith .vb 2239d382aafbSBarry Smith PetscRandomCreate(MPI_Comm, PetscRandom *); 2240d382aafbSBarry Smith PetscRandomSetType(PetscRandom,"my_random_name"); 2241d382aafbSBarry Smith .ve 2242d382aafbSBarry Smith or at runtime via the option 2243d382aafbSBarry Smith .vb 2244d382aafbSBarry Smith -random_type my_random_name 2245d382aafbSBarry Smith .ve 2246d382aafbSBarry Smith 2247d382aafbSBarry Smith Notes: $PETSC_ARCH occuring in pathname will be replaced with appropriate values. 2248d382aafbSBarry Smith 2249d382aafbSBarry Smith For an example of the code needed to interface your own random number generator see 2250d382aafbSBarry Smith src/sys/random/impls/rand/rand.c 2251d382aafbSBarry Smith 2252d382aafbSBarry Smith Level: advanced 2253d382aafbSBarry Smith 2254d382aafbSBarry Smith .keywords: PetscRandom, register 2255d382aafbSBarry Smith .seealso: PetscRandomRegisterAll(), PetscRandomRegisterDestroy(), PetscRandomRegister() 2256d382aafbSBarry Smith M*/ 2257d382aafbSBarry Smith #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 2258d382aafbSBarry Smith #define PetscRandomRegisterDynamic(a,b,c,d) PetscRandomRegister(a,b,c,0) 2259d382aafbSBarry Smith #else 2260d382aafbSBarry Smith #define PetscRandomRegisterDynamic(a,b,c,d) PetscRandomRegister(a,b,c,d) 2261d382aafbSBarry Smith #endif 2262d382aafbSBarry Smith 2263d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomCreate(MPI_Comm,PetscRandom*); 2264d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetValue(PetscRandom,PetscScalar*); 2265d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetValueReal(PetscRandom,PetscReal*); 2266d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetInterval(PetscRandom,PetscScalar*,PetscScalar*); 2267d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSetInterval(PetscRandom,PetscScalar,PetscScalar); 2268d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSetSeed(PetscRandom,unsigned long); 2269d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetSeed(PetscRandom,unsigned long *); 2270d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSeed(PetscRandom); 2271d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomDestroy(PetscRandom); 2272d382aafbSBarry Smith 2273d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetFullPath(const char[],char[],size_t); 2274d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetRelativePath(const char[],char[],size_t); 2275d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetWorkingDirectory(char[],size_t); 2276d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetRealPath(const char[],char[]); 2277d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetHomeDirectory(char[],size_t); 2278d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTestFile(const char[],char,PetscTruth*); 2279d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTestDirectory(const char[],char,PetscTruth*); 2280d382aafbSBarry Smith 2281d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinaryRead(int,void*,PetscInt,PetscDataType); 2282d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinarySynchronizedRead(MPI_Comm,int,void*,PetscInt,PetscDataType); 2283d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinarySynchronizedWrite(MPI_Comm,int,void*,PetscInt,PetscDataType,PetscTruth); 2284d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinaryWrite(int,void*,PetscInt,PetscDataType,PetscTruth); 2285d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinaryOpen(const char[],PetscFileMode,int *); 2286d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinaryClose(int); 2287d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSharedTmp(MPI_Comm,PetscTruth *); 2288d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSharedWorkingDirectory(MPI_Comm,PetscTruth *); 2289d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetTmp(MPI_Comm,char[],size_t); 2290d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFileRetrieve(MPI_Comm,const char[],char[],size_t,PetscTruth*); 2291d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLs(MPI_Comm,const char[],char[],size_t,PetscTruth*); 2292d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenSocket(char*,int,int*); 2293d382aafbSBarry Smith 2294d382aafbSBarry Smith /* 2295d382aafbSBarry Smith In binary files variables are stored using the following lengths, 2296d382aafbSBarry Smith regardless of how they are stored in memory on any one particular 2297d382aafbSBarry Smith machine. Use these rather then sizeof() in computing sizes for 2298d382aafbSBarry Smith PetscBinarySeek(). 2299d382aafbSBarry Smith */ 2300d382aafbSBarry Smith #define PETSC_BINARY_INT_SIZE (32/8) 2301d382aafbSBarry Smith #define PETSC_BINARY_FLOAT_SIZE (32/8) 2302d382aafbSBarry Smith #define PETSC_BINARY_CHAR_SIZE (8/8) 2303d382aafbSBarry Smith #define PETSC_BINARY_SHORT_SIZE (16/8) 2304d382aafbSBarry Smith #define PETSC_BINARY_DOUBLE_SIZE (64/8) 2305d382aafbSBarry Smith #define PETSC_BINARY_SCALAR_SIZE sizeof(PetscScalar) 2306d382aafbSBarry Smith 2307d382aafbSBarry Smith /*E 2308d382aafbSBarry Smith PetscBinarySeekType - argument to PetscBinarySeek() 2309d382aafbSBarry Smith 2310d382aafbSBarry Smith Level: advanced 2311d382aafbSBarry Smith 2312d382aafbSBarry Smith .seealso: PetscBinarySeek(), PetscBinarySynchronizedSeek() 2313d382aafbSBarry Smith E*/ 2314d382aafbSBarry Smith typedef enum {PETSC_BINARY_SEEK_SET = 0,PETSC_BINARY_SEEK_CUR = 1,PETSC_BINARY_SEEK_END = 2} PetscBinarySeekType; 2315d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinarySeek(int,off_t,PetscBinarySeekType,off_t*); 2316d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinarySynchronizedSeek(MPI_Comm,int,off_t,PetscBinarySeekType,off_t*); 2317d382aafbSBarry Smith 2318d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDebugTerminal(const char[]); 2319d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDebugger(const char[],PetscTruth); 2320d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDefaultDebugger(void); 2321d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDebuggerFromString(char*); 2322d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscAttachDebugger(void); 2323d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStopForDebugger(void); 2324d382aafbSBarry Smith 2325d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGatherNumberOfMessages(MPI_Comm,const PetscMPIInt[],const PetscMPIInt[],PetscMPIInt*); 2326d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGatherMessageLengths(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],PetscMPIInt**,PetscMPIInt**); 2327d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGatherMessageLengths2(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscMPIInt**,PetscMPIInt**,PetscMPIInt**); 2328d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPostIrecvInt(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscInt***,MPI_Request**); 2329d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPostIrecvScalar(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscScalar***,MPI_Request**); 2330d382aafbSBarry Smith 2331d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSSEIsEnabled(MPI_Comm,PetscTruth *,PetscTruth *); 2332d382aafbSBarry Smith 2333d382aafbSBarry Smith /*E 2334d382aafbSBarry Smith InsertMode - Whether entries are inserted or added into vectors or matrices 2335d382aafbSBarry Smith 2336d382aafbSBarry Smith Level: beginner 2337d382aafbSBarry Smith 2338d382aafbSBarry Smith .seealso: VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(), 2339d382aafbSBarry Smith VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), 2340d382aafbSBarry Smith MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd() 2341d382aafbSBarry Smith E*/ 2342d382aafbSBarry Smith typedef enum {NOT_SET_VALUES, INSERT_VALUES, ADD_VALUES, MAX_VALUES} InsertMode; 2343d382aafbSBarry Smith 2344d382aafbSBarry Smith /*MC 2345d382aafbSBarry Smith INSERT_VALUES - Put a value into a vector or matrix, overwrites any previous value 2346d382aafbSBarry Smith 2347d382aafbSBarry Smith Level: beginner 2348d382aafbSBarry Smith 2349d382aafbSBarry Smith .seealso: InsertMode, VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(), 2350d382aafbSBarry Smith VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), ADD_VALUES, INSERT_VALUES, 2351d382aafbSBarry Smith MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd() 2352d382aafbSBarry Smith 2353d382aafbSBarry Smith M*/ 2354d382aafbSBarry Smith 2355d382aafbSBarry Smith /*MC 2356d382aafbSBarry Smith ADD_VALUES - Adds a value into a vector or matrix, if there previously was no value, just puts the 2357d382aafbSBarry Smith value into that location 2358d382aafbSBarry Smith 2359d382aafbSBarry Smith Level: beginner 2360d382aafbSBarry Smith 2361d382aafbSBarry Smith .seealso: InsertMode, VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(), 2362d382aafbSBarry Smith VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), ADD_VALUES, INSERT_VALUES, 2363d382aafbSBarry Smith MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd() 2364d382aafbSBarry Smith 2365d382aafbSBarry Smith M*/ 2366d382aafbSBarry Smith 2367d382aafbSBarry Smith /*MC 2368d382aafbSBarry Smith MAX_VALUES - Puts the maximum of the scattered/gathered value and the current value into each location 2369d382aafbSBarry Smith 2370d382aafbSBarry Smith Level: beginner 2371d382aafbSBarry Smith 2372d382aafbSBarry Smith .seealso: InsertMode, VecScatterBegin(), VecScatterEnd(), ADD_VALUES, INSERT_VALUES 2373d382aafbSBarry Smith 2374d382aafbSBarry Smith M*/ 2375d382aafbSBarry Smith 2376d382aafbSBarry Smith /*E 2377d382aafbSBarry Smith ScatterMode - Determines the direction of a scatter 2378d382aafbSBarry Smith 2379d382aafbSBarry Smith Level: beginner 2380d382aafbSBarry Smith 2381d382aafbSBarry Smith .seealso: VecScatter, VecScatterBegin(), VecScatterEnd() 2382d382aafbSBarry Smith E*/ 2383d382aafbSBarry Smith typedef enum {SCATTER_FORWARD=0, SCATTER_REVERSE=1, SCATTER_FORWARD_LOCAL=2, SCATTER_REVERSE_LOCAL=3, SCATTER_LOCAL=2} ScatterMode; 2384d382aafbSBarry Smith 2385d382aafbSBarry Smith /*MC 2386d382aafbSBarry Smith SCATTER_FORWARD - Scatters the values as dictated by the VecScatterCreate() call 2387d382aafbSBarry Smith 2388d382aafbSBarry Smith Level: beginner 2389d382aafbSBarry Smith 2390d382aafbSBarry Smith .seealso: VecScatter, ScatterMode, VecScatterCreate(), VecScatterBegin(), VecScatterEnd(), SCATTER_REVERSE, SCATTER_FORWARD_LOCAL, 2391d382aafbSBarry Smith SCATTER_REVERSE_LOCAL 2392d382aafbSBarry Smith 2393d382aafbSBarry Smith M*/ 2394d382aafbSBarry Smith 2395d382aafbSBarry Smith /*MC 2396d382aafbSBarry Smith SCATTER_REVERSE - Moves the values in the opposite direction then the directions indicated in 2397d382aafbSBarry Smith in the VecScatterCreate() 2398d382aafbSBarry Smith 2399d382aafbSBarry Smith Level: beginner 2400d382aafbSBarry Smith 2401d382aafbSBarry Smith .seealso: VecScatter, ScatterMode, VecScatterCreate(), VecScatterBegin(), VecScatterEnd(), SCATTER_FORWARD, SCATTER_FORWARD_LOCAL, 2402d382aafbSBarry Smith SCATTER_REVERSE_LOCAL 2403d382aafbSBarry Smith 2404d382aafbSBarry Smith M*/ 2405d382aafbSBarry Smith 2406d382aafbSBarry Smith /*MC 2407d382aafbSBarry Smith SCATTER_FORWARD_LOCAL - Scatters the values as dictated by the VecScatterCreate() call except NO parallel communication 2408d382aafbSBarry Smith is done. Any variables that have be moved between processes are ignored 2409d382aafbSBarry Smith 2410d382aafbSBarry Smith Level: developer 2411d382aafbSBarry Smith 2412d382aafbSBarry Smith .seealso: VecScatter, ScatterMode, VecScatterCreate(), VecScatterBegin(), VecScatterEnd(), SCATTER_REVERSE, SCATTER_FORWARD, 2413d382aafbSBarry Smith SCATTER_REVERSE_LOCAL 2414d382aafbSBarry Smith 2415d382aafbSBarry Smith M*/ 2416d382aafbSBarry Smith 2417d382aafbSBarry Smith /*MC 2418d382aafbSBarry Smith SCATTER_REVERSE_LOCAL - Moves the values in the opposite direction then the directions indicated in 2419d382aafbSBarry Smith in the VecScatterCreate() except NO parallel communication 2420d382aafbSBarry Smith is done. Any variables that have be moved between processes are ignored 2421d382aafbSBarry Smith 2422d382aafbSBarry Smith Level: developer 2423d382aafbSBarry Smith 2424d382aafbSBarry Smith .seealso: VecScatter, ScatterMode, VecScatterCreate(), VecScatterBegin(), VecScatterEnd(), SCATTER_FORWARD, SCATTER_FORWARD_LOCAL, 2425d382aafbSBarry Smith SCATTER_REVERSE 2426d382aafbSBarry Smith 2427d382aafbSBarry Smith M*/ 2428d382aafbSBarry Smith 2429d382aafbSBarry Smith /*S 2430d382aafbSBarry Smith PetscSubcomm - Context of MPI subcommunicators, used by PCREDUNDANT 2431d382aafbSBarry Smith 2432d382aafbSBarry Smith Level: advanced 2433d382aafbSBarry Smith 2434d382aafbSBarry Smith Concepts: communicator, create 2435d382aafbSBarry Smith S*/ 2436d382aafbSBarry Smith typedef struct _n_PetscSubcomm* PetscSubcomm; 2437d382aafbSBarry Smith 2438d382aafbSBarry Smith struct _n_PetscSubcomm { 2439d382aafbSBarry Smith MPI_Comm parent; /* parent communicator */ 2440d382aafbSBarry Smith MPI_Comm dupparent; /* duplicate parent communicator, under which the processors of this subcomm have contiguous rank */ 2441d382aafbSBarry Smith MPI_Comm comm; /* this communicator */ 2442d382aafbSBarry Smith PetscInt n; /* num of subcommunicators under the parent communicator */ 2443d382aafbSBarry Smith PetscInt color; /* color of processors belong to this communicator */ 2444d382aafbSBarry Smith }; 2445d382aafbSBarry Smith 2446d382aafbSBarry Smith EXTERN PetscErrorCode PETSCMAT_DLLEXPORT PetscSubcommCreate(MPI_Comm,PetscInt,PetscSubcomm*); 2447d382aafbSBarry Smith EXTERN PetscErrorCode PETSCMAT_DLLEXPORT PetscSubcommDestroy(PetscSubcomm); 2448d382aafbSBarry Smith 2449d382aafbSBarry Smith PETSC_EXTERN_CXX_END 24506c7e564aSBarry Smith 2451d382aafbSBarry Smith #endif 2452