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 Synopsis: 296d382aafbSBarry Smith PetscPolymorphicSubroutine(Functionname,(arguments of C++ function),(arguments of C function)) 297d382aafbSBarry Smith 298*eca87e8dSBarry Smith Not collective 299*eca87e8dSBarry 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 Synopsis: 316d382aafbSBarry Smith PetscPolymorphicScalar(Functionname,(arguments of C++ function),(arguments of C function)) 317d382aafbSBarry Smith 318*eca87e8dSBarry Smith Not collective 319*eca87e8dSBarry 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 Synopsis: 337d382aafbSBarry Smith PetscPolymorphicFunction(Functionname,(arguments of C++ function),(arguments of C function),return type,return variable name) 338d382aafbSBarry Smith 339*eca87e8dSBarry Smith Not collective 340*eca87e8dSBarry 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 Synopsis: 362d382aafbSBarry Smith PetscTruth PetscUnlikely(PetscTruth cond) 363d382aafbSBarry Smith 364*eca87e8dSBarry Smith Not Collective 365*eca87e8dSBarry 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 Synopsis: 381d382aafbSBarry Smith PetscTruth PetscUnlikely(PetscTruth cond) 382d382aafbSBarry Smith 383*eca87e8dSBarry Smith Not Collective 384*eca87e8dSBarry 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 583*eca87e8dSBarry Smith Synopsis: 584*eca87e8dSBarry Smith PetscErrorCode PetscMalloc(size_t m,void **result) 585*eca87e8dSBarry Smith 586*eca87e8dSBarry Smith Not Collective 587*eca87e8dSBarry Smith 588d382aafbSBarry Smith Input Parameter: 589d382aafbSBarry Smith . m - number of bytes to allocate 590d382aafbSBarry Smith 591d382aafbSBarry Smith Output Parameter: 592d382aafbSBarry Smith . result - memory allocated 593d382aafbSBarry Smith 594d382aafbSBarry Smith Level: beginner 595d382aafbSBarry Smith 596d382aafbSBarry Smith Notes: Memory is always allocated at least double aligned 597d382aafbSBarry Smith 598d382aafbSBarry Smith If you request memory of zero size it will allocate no space and assign the pointer to 0; PetscFree() will 599d382aafbSBarry Smith properly handle not freeing the null pointer. 600d382aafbSBarry Smith 601d382aafbSBarry Smith .seealso: PetscFree(), PetscNew() 602d382aafbSBarry Smith 603d382aafbSBarry Smith Concepts: memory allocation 604d382aafbSBarry Smith 605d382aafbSBarry Smith M*/ 606d382aafbSBarry Smith #define PetscMalloc(a,b) ((a != 0) ? (*PetscTrMalloc)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__,(void**)(b)) : (*(b) = 0,0) ) 607d382aafbSBarry Smith 608d382aafbSBarry Smith /*MC 609d382aafbSBarry Smith PetscAddrAlign - Returns an address with PETSC_MEMALIGN alignment 610d382aafbSBarry Smith 611d382aafbSBarry Smith Synopsis: 612d382aafbSBarry Smith void *PetscAddrAlign(void *addr) 613d382aafbSBarry Smith 614*eca87e8dSBarry Smith Not Collective 615*eca87e8dSBarry Smith 616*eca87e8dSBarry Smith Input Parameters: 617*eca87e8dSBarry Smith . addr - address to align (any pointer type) 618*eca87e8dSBarry Smith 619d382aafbSBarry Smith Level: developer 620d382aafbSBarry Smith 621d382aafbSBarry Smith .seealso: PetscMallocAlign() 622d382aafbSBarry Smith 623d382aafbSBarry Smith Concepts: memory allocation 624d382aafbSBarry Smith M*/ 625d382aafbSBarry Smith #if defined PETSC_UINTPTR_T 626d382aafbSBarry Smith # define PetscAddrAlign(a) (void*)((((PETSC_UINTPTR_T)(a))+(PETSC_MEMALIGN-1)) & ~(PETSC_MEMALIGN-1)) 627d382aafbSBarry Smith #else 628d382aafbSBarry Smith # define PetscAddrAlign(a) (void*)(a) 629d382aafbSBarry Smith #endif 630d382aafbSBarry Smith 631d382aafbSBarry Smith /*MC 632d382aafbSBarry Smith PetscMalloc2 - Allocates 2 chunks of memory 633d382aafbSBarry Smith 634*eca87e8dSBarry Smith Synopsis: 635*eca87e8dSBarry Smith PetscErrorCode PetscMalloc2(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2) 636*eca87e8dSBarry Smith 637*eca87e8dSBarry Smith Not Collective 638*eca87e8dSBarry Smith 639d382aafbSBarry Smith Input Parameter: 640d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 641d382aafbSBarry Smith . t1 - type of first memory elements 642d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 643d382aafbSBarry Smith - t2 - type of second memory elements 644d382aafbSBarry Smith 645d382aafbSBarry Smith Output Parameter: 646d382aafbSBarry Smith + r1 - memory allocated in first chunk 647d382aafbSBarry Smith - r2 - memory allocated in second chunk 648d382aafbSBarry Smith 649d382aafbSBarry Smith Level: developer 650d382aafbSBarry Smith 651d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 652d382aafbSBarry Smith 653d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc() 654d382aafbSBarry Smith 655d382aafbSBarry Smith Concepts: memory allocation 656d382aafbSBarry Smith 657d382aafbSBarry Smith M*/ 658d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 659d382aafbSBarry Smith #define PetscMalloc2(m1,t1,r1,m2,t2,r2) (PetscMalloc((m1)*sizeof(t1),r1) || PetscMalloc((m2)*sizeof(t2),r2)) 660d382aafbSBarry Smith #else 6613b98c0a2SBarry Smith #define PetscMalloc2(m1,t1,r1,m2,t2,r2) ((*(r2) = 0,PetscMalloc((m1)*sizeof(t1)+(m2)*sizeof(t2)+(PETSC_MEMALIGN-1),r1)) \ 662d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),0)) 663d382aafbSBarry Smith #endif 664d382aafbSBarry Smith 665d382aafbSBarry Smith /*MC 666d382aafbSBarry Smith PetscMalloc3 - Allocates 3 chunks of memory 667d382aafbSBarry Smith 668*eca87e8dSBarry Smith Synopsis: 669*eca87e8dSBarry Smith PetscErrorCode PetscMalloc3(size_t m1,type, t1,void **r1,size_t m2,type t2,void **r2,size_t m3,type t3,void **r3) 670*eca87e8dSBarry Smith 671*eca87e8dSBarry Smith Not Collective 672*eca87e8dSBarry Smith 673d382aafbSBarry Smith Input Parameter: 674d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 675d382aafbSBarry Smith . t1 - type of first memory elements 676d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 677d382aafbSBarry Smith . t2 - type of second memory elements 678d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 679d382aafbSBarry Smith - t3 - type of third memory elements 680d382aafbSBarry Smith 681d382aafbSBarry Smith Output Parameter: 682d382aafbSBarry Smith + r1 - memory allocated in first chunk 683d382aafbSBarry Smith . r2 - memory allocated in second chunk 684d382aafbSBarry Smith - r3 - memory allocated in third chunk 685d382aafbSBarry Smith 686d382aafbSBarry Smith 687d382aafbSBarry Smith Level: developer 688d382aafbSBarry Smith 689d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 690d382aafbSBarry Smith 691d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3() 692d382aafbSBarry Smith 693d382aafbSBarry Smith Concepts: memory allocation 694d382aafbSBarry Smith 695d382aafbSBarry Smith M*/ 696d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 697d382aafbSBarry 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)) 698d382aafbSBarry Smith #else 6993b98c0a2SBarry 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)) \ 700d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),*(r3) = (t3*)PetscAddrAlign(*(r2)+m2),0)) 701d382aafbSBarry Smith #endif 702d382aafbSBarry Smith 703d382aafbSBarry Smith /*MC 704d382aafbSBarry Smith PetscMalloc4 - Allocates 4 chunks of memory 705d382aafbSBarry Smith 706*eca87e8dSBarry Smith Synopsis: 707*eca87e8dSBarry 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) 708*eca87e8dSBarry Smith 709*eca87e8dSBarry Smith Not Collective 710*eca87e8dSBarry Smith 711d382aafbSBarry Smith Input Parameter: 712d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 713d382aafbSBarry Smith . t1 - type of first memory elements 714d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 715d382aafbSBarry Smith . t2 - type of second memory elements 716d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 717d382aafbSBarry Smith . t3 - type of third memory elements 718d382aafbSBarry Smith . m4 - number of elements to allocate in 4th chunk (may be zero) 719d382aafbSBarry Smith - t4 - type of fourth memory elements 720d382aafbSBarry Smith 721d382aafbSBarry Smith Output Parameter: 722d382aafbSBarry Smith + r1 - memory allocated in first chunk 723d382aafbSBarry Smith . r2 - memory allocated in second chunk 724d382aafbSBarry Smith . r3 - memory allocated in third chunk 725d382aafbSBarry Smith - r4 - memory allocated in fourth chunk 726d382aafbSBarry Smith 727d382aafbSBarry Smith Level: developer 728d382aafbSBarry Smith 729d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 730d382aafbSBarry Smith 731d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4() 732d382aafbSBarry Smith 733d382aafbSBarry Smith Concepts: memory allocation 734d382aafbSBarry Smith 735d382aafbSBarry Smith M*/ 736d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 737d382aafbSBarry 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)) 738d382aafbSBarry Smith #else 739d382aafbSBarry Smith #define PetscMalloc4(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4) \ 7403b98c0a2SBarry 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)) \ 741d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),*(r3) = (t3*)PetscAddrAlign(*(r2)+m2),*(r4) = (t4*)PetscAddrAlign(*(r3)+m3),0)) 742d382aafbSBarry Smith #endif 743d382aafbSBarry Smith 744d382aafbSBarry Smith /*MC 745d382aafbSBarry Smith PetscMalloc5 - Allocates 5 chunks of memory 746d382aafbSBarry Smith 747*eca87e8dSBarry Smith Synopsis: 748*eca87e8dSBarry 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) 749*eca87e8dSBarry Smith 750*eca87e8dSBarry Smith Not Collective 751*eca87e8dSBarry Smith 752d382aafbSBarry Smith Input Parameter: 753d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 754d382aafbSBarry Smith . t1 - type of first memory elements 755d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 756d382aafbSBarry Smith . t2 - type of second memory elements 757d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 758d382aafbSBarry Smith . t3 - type of third memory elements 759d382aafbSBarry Smith . m4 - number of elements to allocate in 4th chunk (may be zero) 760d382aafbSBarry Smith . t4 - type of fourth memory elements 761d382aafbSBarry Smith . m5 - number of elements to allocate in 5th chunk (may be zero) 762d382aafbSBarry Smith - t5 - type of fifth memory elements 763d382aafbSBarry Smith 764d382aafbSBarry Smith Output Parameter: 765d382aafbSBarry Smith + r1 - memory allocated in first chunk 766d382aafbSBarry Smith . r2 - memory allocated in second chunk 767d382aafbSBarry Smith . r3 - memory allocated in third chunk 768d382aafbSBarry Smith . r4 - memory allocated in fourth chunk 769d382aafbSBarry Smith - r5 - memory allocated in fifth chunk 770d382aafbSBarry Smith 771d382aafbSBarry Smith Level: developer 772d382aafbSBarry Smith 773d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 774d382aafbSBarry Smith 775d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5() 776d382aafbSBarry Smith 777d382aafbSBarry Smith Concepts: memory allocation 778d382aafbSBarry Smith 779d382aafbSBarry Smith M*/ 780d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 781d382aafbSBarry 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)) 782d382aafbSBarry Smith #else 783d382aafbSBarry Smith #define PetscMalloc5(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5) \ 7843b98c0a2SBarry 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)) \ 785d382aafbSBarry Smith || (*(r2) = (t2*)PetscAddrAlign(*(r1)+m1),*(r3) = (t3*)PetscAddrAlign(*(r2)+m2),*(r4) = (t4*)PetscAddrAlign(*(r3)+m3),*(r5) = (t5*)PetscAddrAlign(*(r4)+m4),0)) 786d382aafbSBarry Smith #endif 787d382aafbSBarry Smith 788d382aafbSBarry Smith 789d382aafbSBarry Smith /*MC 790d382aafbSBarry Smith PetscMalloc6 - Allocates 6 chunks of memory 791d382aafbSBarry Smith 792*eca87e8dSBarry Smith Synopsis: 793*eca87e8dSBarry 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) 794*eca87e8dSBarry Smith 795*eca87e8dSBarry Smith Not Collective 796*eca87e8dSBarry Smith 797d382aafbSBarry Smith Input Parameter: 798d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 799d382aafbSBarry Smith . t1 - type of first memory elements 800d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 801d382aafbSBarry Smith . t2 - type of second memory elements 802d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 803d382aafbSBarry Smith . t3 - type of third memory elements 804d382aafbSBarry Smith . m4 - number of elements to allocate in 4th chunk (may be zero) 805d382aafbSBarry Smith . t4 - type of fourth memory elements 806d382aafbSBarry Smith . m5 - number of elements to allocate in 5th chunk (may be zero) 807d382aafbSBarry Smith . t5 - type of fifth memory elements 808d382aafbSBarry Smith . m6 - number of elements to allocate in 6th chunk (may be zero) 809d382aafbSBarry Smith - t6 - type of sixth memory elements 810d382aafbSBarry Smith 811d382aafbSBarry Smith Output Parameter: 812d382aafbSBarry Smith + r1 - memory allocated in first chunk 813d382aafbSBarry Smith . r2 - memory allocated in second chunk 814d382aafbSBarry Smith . r3 - memory allocated in third chunk 815d382aafbSBarry Smith . r4 - memory allocated in fourth chunk 816d382aafbSBarry Smith . r5 - memory allocated in fifth chunk 817d382aafbSBarry Smith - r6 - memory allocated in sixth chunk 818d382aafbSBarry Smith 819d382aafbSBarry Smith Level: developer 820d382aafbSBarry Smith 821d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 822d382aafbSBarry Smith 823d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5(), PetscFree6() 824d382aafbSBarry Smith 825d382aafbSBarry Smith Concepts: memory allocation 826d382aafbSBarry Smith 827d382aafbSBarry Smith M*/ 828d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 829d382aafbSBarry 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)) 830d382aafbSBarry Smith #else 831d382aafbSBarry Smith #define PetscMalloc6(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5,m6,t6,r6) \ 8323b98c0a2SBarry 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)) \ 833d382aafbSBarry 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)) 834d382aafbSBarry Smith #endif 835d382aafbSBarry Smith 836d382aafbSBarry Smith /*MC 837d382aafbSBarry Smith PetscMalloc7 - Allocates 7 chunks of memory 838d382aafbSBarry Smith 839*eca87e8dSBarry Smith Synopsis: 840*eca87e8dSBarry 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) 841*eca87e8dSBarry Smith 842*eca87e8dSBarry Smith Not Collective 843*eca87e8dSBarry Smith 844d382aafbSBarry Smith Input Parameter: 845d382aafbSBarry Smith + m1 - number of elements to allocate in 1st chunk (may be zero) 846d382aafbSBarry Smith . t1 - type of first memory elements 847d382aafbSBarry Smith . m2 - number of elements to allocate in 2nd chunk (may be zero) 848d382aafbSBarry Smith . t2 - type of second memory elements 849d382aafbSBarry Smith . m3 - number of elements to allocate in 3rd chunk (may be zero) 850d382aafbSBarry Smith . t3 - type of third memory elements 851d382aafbSBarry Smith . m4 - number of elements to allocate in 4th chunk (may be zero) 852d382aafbSBarry Smith . t4 - type of fourth memory elements 853d382aafbSBarry Smith . m5 - number of elements to allocate in 5th chunk (may be zero) 854d382aafbSBarry Smith . t5 - type of fifth memory elements 855d382aafbSBarry Smith . m6 - number of elements to allocate in 6th chunk (may be zero) 856d382aafbSBarry Smith . t6 - type of sixth memory elements 857d382aafbSBarry Smith . m7 - number of elements to allocate in 7th chunk (may be zero) 858d382aafbSBarry Smith - t7 - type of sixth memory elements 859d382aafbSBarry Smith 860d382aafbSBarry Smith Output Parameter: 861d382aafbSBarry Smith + r1 - memory allocated in first chunk 862d382aafbSBarry Smith . r2 - memory allocated in second chunk 863d382aafbSBarry Smith . r3 - memory allocated in third chunk 864d382aafbSBarry Smith . r4 - memory allocated in fourth chunk 865d382aafbSBarry Smith . r5 - memory allocated in fifth chunk 866d382aafbSBarry Smith . r6 - memory allocated in sixth chunk 867*eca87e8dSBarry Smith - r7 - memory allocated in seventh chunk 868d382aafbSBarry Smith 869d382aafbSBarry Smith Level: developer 870d382aafbSBarry Smith 871d382aafbSBarry Smith Notes: Memory of first chunk is always allocated at least double aligned 872d382aafbSBarry Smith 873d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree3(), PetscFree4(), PetscFree5(), PetscFree6(), PetscFree7() 874d382aafbSBarry Smith 875d382aafbSBarry Smith Concepts: memory allocation 876d382aafbSBarry Smith 877d382aafbSBarry Smith M*/ 878d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 879d382aafbSBarry 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)) 880d382aafbSBarry Smith #else 881d382aafbSBarry Smith #define PetscMalloc7(m1,t1,r1,m2,t2,r2,m3,t3,r3,m4,t4,r4,m5,t5,r5,m6,t6,r6,m7,t7,r7) \ 8823b98c0a2SBarry 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)) \ 883d382aafbSBarry 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)) 884d382aafbSBarry Smith #endif 885d382aafbSBarry Smith 886d382aafbSBarry Smith /*MC 887d382aafbSBarry Smith PetscNew - Allocates memory of a particular type, zeros the memory! 888d382aafbSBarry Smith 889*eca87e8dSBarry Smith Synopsis: 890*eca87e8dSBarry Smith PetscErrorCode PetscNew(struct type,((type *))result) 891*eca87e8dSBarry Smith 892*eca87e8dSBarry Smith Not Collective 893*eca87e8dSBarry Smith 894d382aafbSBarry Smith Input Parameter: 895d382aafbSBarry Smith . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated 896d382aafbSBarry Smith 897d382aafbSBarry Smith Output Parameter: 898d382aafbSBarry Smith . result - memory allocated 899d382aafbSBarry Smith 900d382aafbSBarry Smith Level: beginner 901d382aafbSBarry Smith 902d382aafbSBarry Smith .seealso: PetscFree(), PetscMalloc() 903d382aafbSBarry Smith 904d382aafbSBarry Smith Concepts: memory allocation 905d382aafbSBarry Smith 906d382aafbSBarry Smith M*/ 907d382aafbSBarry Smith #define PetscNew(A,b) (PetscMalloc(sizeof(A),(b)) || PetscMemzero(*(b),sizeof(A))) 908d382aafbSBarry Smith #define PetscNewLog(o,A,b) (PetscNew(A,b) || ((o) ? PetscLogObjectMemory(o,sizeof(A)) : 0)) 909d382aafbSBarry Smith 910d382aafbSBarry Smith /*MC 911d382aafbSBarry Smith PetscFree - Frees memory 912d382aafbSBarry Smith 913*eca87e8dSBarry Smith Synopsis: 914*eca87e8dSBarry Smith PetscErrorCode PetscFree(void *memory) 915*eca87e8dSBarry Smith 916*eca87e8dSBarry Smith Not Collective 917*eca87e8dSBarry Smith 918d382aafbSBarry Smith Input Parameter: 919d382aafbSBarry Smith . memory - memory to free (the pointer is ALWAYS set to 0 upon sucess) 920d382aafbSBarry Smith 921d382aafbSBarry Smith 922d382aafbSBarry Smith Level: beginner 923d382aafbSBarry Smith 924d382aafbSBarry Smith Notes: Memory must have been obtained with PetscNew() or PetscMalloc() 925d382aafbSBarry Smith 926d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscFreeVoid() 927d382aafbSBarry Smith 928d382aafbSBarry Smith Concepts: memory allocation 929d382aafbSBarry Smith 930d382aafbSBarry Smith M*/ 931d382aafbSBarry Smith #define PetscFree(a) ((a) ? ((*PetscTrFree)((void*)(a),__LINE__,__FUNCT__,__FILE__,__SDIR__) || ((a = 0),0)) : 0) 932d382aafbSBarry Smith 933d382aafbSBarry Smith /*MC 934d382aafbSBarry Smith PetscFreeVoid - Frees memory 935d382aafbSBarry Smith 936d382aafbSBarry Smith Synopsis: 937d382aafbSBarry Smith void PetscFreeVoid(void *memory) 938d382aafbSBarry Smith 939*eca87e8dSBarry Smith Not Collective 940*eca87e8dSBarry Smith 941*eca87e8dSBarry Smith Input Parameter: 942*eca87e8dSBarry Smith . memory - memory to free 943*eca87e8dSBarry Smith 944d382aafbSBarry Smith Level: beginner 945d382aafbSBarry Smith 946d382aafbSBarry Smith Notes: This is different from PetscFree() in that no error code is returned 947d382aafbSBarry Smith 948d382aafbSBarry Smith .seealso: PetscFree(), PetscNew(), PetscMalloc() 949d382aafbSBarry Smith 950d382aafbSBarry Smith Concepts: memory allocation 951d382aafbSBarry Smith 952d382aafbSBarry Smith M*/ 953d382aafbSBarry Smith #define PetscFreeVoid(a) ((*PetscTrFree)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__),(a) = 0) 954d382aafbSBarry Smith 955d382aafbSBarry Smith 956d382aafbSBarry Smith /*MC 957d382aafbSBarry Smith PetscFree2 - Frees 2 chunks of memory obtained with PetscMalloc2() 958d382aafbSBarry Smith 959*eca87e8dSBarry Smith Synopsis: 960*eca87e8dSBarry Smith PetscErrorCode PetscFree2(void *memory1,void *memory2) 961*eca87e8dSBarry Smith 962*eca87e8dSBarry Smith Not Collective 963*eca87e8dSBarry Smith 964d382aafbSBarry Smith Input Parameter: 965d382aafbSBarry Smith + memory1 - memory to free 966d382aafbSBarry Smith - memory2 - 2nd memory to free 967d382aafbSBarry Smith 968d382aafbSBarry Smith Level: developer 969d382aafbSBarry Smith 970d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc2() 971d382aafbSBarry Smith 972d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree() 973d382aafbSBarry Smith 974d382aafbSBarry Smith Concepts: memory allocation 975d382aafbSBarry Smith 976d382aafbSBarry Smith M*/ 977d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 978d382aafbSBarry Smith #define PetscFree2(m1,m2) (PetscFree(m2) || PetscFree(m1)) 979d382aafbSBarry Smith #else 980d382aafbSBarry Smith #define PetscFree2(m1,m2) (PetscFree(m1)) 981d382aafbSBarry Smith #endif 982d382aafbSBarry Smith 983d382aafbSBarry Smith /*MC 984d382aafbSBarry Smith PetscFree3 - Frees 3 chunks of memory obtained with PetscMalloc3() 985d382aafbSBarry Smith 986*eca87e8dSBarry Smith Synopsis: 987*eca87e8dSBarry Smith PetscErrorCode PetscFree3(void *memory1,void *memory2,void *memory3) 988*eca87e8dSBarry Smith 989*eca87e8dSBarry Smith Not Collective 990*eca87e8dSBarry Smith 991d382aafbSBarry Smith Input Parameter: 992d382aafbSBarry Smith + memory1 - memory to free 993d382aafbSBarry Smith . memory2 - 2nd memory to free 994d382aafbSBarry Smith - memory3 - 3rd memory to free 995d382aafbSBarry Smith 996d382aafbSBarry Smith Level: developer 997d382aafbSBarry Smith 998d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc3() 999d382aafbSBarry Smith 1000d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3() 1001d382aafbSBarry Smith 1002d382aafbSBarry Smith Concepts: memory allocation 1003d382aafbSBarry Smith 1004d382aafbSBarry Smith M*/ 1005d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1006d382aafbSBarry Smith #define PetscFree3(m1,m2,m3) (PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1007d382aafbSBarry Smith #else 1008d382aafbSBarry Smith #define PetscFree3(m1,m2,m3) (PetscFree(m1)) 1009d382aafbSBarry Smith #endif 1010d382aafbSBarry Smith 1011d382aafbSBarry Smith /*MC 1012d382aafbSBarry Smith PetscFree4 - Frees 4 chunks of memory obtained with PetscMalloc4() 1013d382aafbSBarry Smith 1014*eca87e8dSBarry Smith Synopsis: 1015*eca87e8dSBarry Smith PetscErrorCode PetscFree4(void *m1,void *m2,void *m3,void *m4) 1016*eca87e8dSBarry Smith 1017*eca87e8dSBarry Smith Not Collective 1018*eca87e8dSBarry Smith 1019d382aafbSBarry Smith Input Parameter: 1020d382aafbSBarry Smith + m1 - memory to free 1021d382aafbSBarry Smith . m2 - 2nd memory to free 1022d382aafbSBarry Smith . m3 - 3rd memory to free 1023d382aafbSBarry Smith - m4 - 4th memory to free 1024d382aafbSBarry Smith 1025d382aafbSBarry Smith Level: developer 1026d382aafbSBarry Smith 1027d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc4() 1028d382aafbSBarry Smith 1029d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4() 1030d382aafbSBarry Smith 1031d382aafbSBarry Smith Concepts: memory allocation 1032d382aafbSBarry Smith 1033d382aafbSBarry Smith M*/ 1034d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1035d382aafbSBarry Smith #define PetscFree4(m1,m2,m3,m4) (PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1036d382aafbSBarry Smith #else 1037d382aafbSBarry Smith #define PetscFree4(m1,m2,m3,m4) (PetscFree(m1)) 1038d382aafbSBarry Smith #endif 1039d382aafbSBarry Smith 1040d382aafbSBarry Smith /*MC 1041d382aafbSBarry Smith PetscFree5 - Frees 5 chunks of memory obtained with PetscMalloc5() 1042d382aafbSBarry Smith 1043*eca87e8dSBarry Smith Synopsis: 1044*eca87e8dSBarry Smith PetscErrorCode PetscFree5(void *m1,void *m2,void *m3,void *m4,void *m5) 1045*eca87e8dSBarry Smith 1046*eca87e8dSBarry Smith Not Collective 1047*eca87e8dSBarry Smith 1048d382aafbSBarry Smith Input Parameter: 1049d382aafbSBarry Smith + m1 - memory to free 1050d382aafbSBarry Smith . m2 - 2nd memory to free 1051d382aafbSBarry Smith . m3 - 3rd memory to free 1052d382aafbSBarry Smith . m4 - 4th memory to free 1053d382aafbSBarry Smith - m5 - 5th memory to free 1054d382aafbSBarry Smith 1055d382aafbSBarry Smith Level: developer 1056d382aafbSBarry Smith 1057d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc5() 1058d382aafbSBarry Smith 1059d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5() 1060d382aafbSBarry Smith 1061d382aafbSBarry Smith Concepts: memory allocation 1062d382aafbSBarry Smith 1063d382aafbSBarry Smith M*/ 1064d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1065d382aafbSBarry Smith #define PetscFree5(m1,m2,m3,m4,m5) (PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1066d382aafbSBarry Smith #else 1067d382aafbSBarry Smith #define PetscFree5(m1,m2,m3,m4,m5) (PetscFree(m1)) 1068d382aafbSBarry Smith #endif 1069d382aafbSBarry Smith 1070d382aafbSBarry Smith 1071d382aafbSBarry Smith /*MC 1072d382aafbSBarry Smith PetscFree6 - Frees 6 chunks of memory obtained with PetscMalloc6() 1073d382aafbSBarry Smith 1074*eca87e8dSBarry Smith Synopsis: 1075*eca87e8dSBarry Smith PetscErrorCode PetscFree6(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6) 1076*eca87e8dSBarry Smith 1077*eca87e8dSBarry Smith Not Collective 1078*eca87e8dSBarry Smith 1079d382aafbSBarry Smith Input Parameter: 1080d382aafbSBarry Smith + m1 - memory to free 1081d382aafbSBarry Smith . m2 - 2nd memory to free 1082d382aafbSBarry Smith . m3 - 3rd memory to free 1083d382aafbSBarry Smith . m4 - 4th memory to free 1084d382aafbSBarry Smith . m5 - 5th memory to free 1085d382aafbSBarry Smith - m6 - 6th memory to free 1086d382aafbSBarry Smith 1087d382aafbSBarry Smith 1088d382aafbSBarry Smith Level: developer 1089d382aafbSBarry Smith 1090d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc6() 1091d382aafbSBarry Smith 1092d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5(), PetscMalloc6() 1093d382aafbSBarry Smith 1094d382aafbSBarry Smith Concepts: memory allocation 1095d382aafbSBarry Smith 1096d382aafbSBarry Smith M*/ 1097d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1098d382aafbSBarry Smith #define PetscFree6(m1,m2,m3,m4,m5,m6) (PetscFree(m6) || PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1099d382aafbSBarry Smith #else 1100d382aafbSBarry Smith #define PetscFree6(m1,m2,m3,m4,m5,m6) (PetscFree(m1)) 1101d382aafbSBarry Smith #endif 1102d382aafbSBarry Smith 1103d382aafbSBarry Smith /*MC 1104d382aafbSBarry Smith PetscFree7 - Frees 7 chunks of memory obtained with PetscMalloc7() 1105d382aafbSBarry Smith 1106*eca87e8dSBarry Smith Synopsis: 1107*eca87e8dSBarry Smith PetscErrorCode PetscFree7(void *m1,void *m2,void *m3,void *m4,void *m5,void *m6,void *m7) 1108*eca87e8dSBarry Smith 1109*eca87e8dSBarry Smith Not Collective 1110*eca87e8dSBarry Smith 1111d382aafbSBarry Smith Input Parameter: 1112d382aafbSBarry Smith + m1 - memory to free 1113d382aafbSBarry Smith . m2 - 2nd memory to free 1114d382aafbSBarry Smith . m3 - 3rd memory to free 1115d382aafbSBarry Smith . m4 - 4th memory to free 1116d382aafbSBarry Smith . m5 - 5th memory to free 1117d382aafbSBarry Smith . m6 - 6th memory to free 1118d382aafbSBarry Smith - m7 - 7th memory to free 1119d382aafbSBarry Smith 1120d382aafbSBarry Smith 1121d382aafbSBarry Smith Level: developer 1122d382aafbSBarry Smith 1123d382aafbSBarry Smith Notes: Memory must have been obtained with PetscMalloc7() 1124d382aafbSBarry Smith 1125d382aafbSBarry Smith .seealso: PetscNew(), PetscMalloc(), PetscMalloc2(), PetscFree(), PetscMalloc3(), PetscMalloc4(), PetscMalloc5(), PetscMalloc6(), 1126d382aafbSBarry Smith PetscMalloc7() 1127d382aafbSBarry Smith 1128d382aafbSBarry Smith Concepts: memory allocation 1129d382aafbSBarry Smith 1130d382aafbSBarry Smith M*/ 1131d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1132d382aafbSBarry Smith #define PetscFree7(m1,m2,m3,m4,m5,m6,m7) (PetscFree(m7) || PetscFree(m6) || PetscFree(m5) || PetscFree(m4) || PetscFree(m3) || PetscFree(m2) || PetscFree(m1)) 1133d382aafbSBarry Smith #else 1134d382aafbSBarry Smith #define PetscFree7(m1,m2,m3,m4,m5,m6,m7) (PetscFree(m1)) 1135d382aafbSBarry Smith #endif 1136d382aafbSBarry Smith 1137d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT PetscErrorCode (*PetscTrMalloc)(size_t,int,const char[],const char[],const char[],void**); 1138d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT PetscErrorCode (*PetscTrFree)(void*,int,const char[],const char[],const char[]); 1139d382aafbSBarry 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[])); 1140d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocClear(void); 1141d382aafbSBarry Smith 1142d382aafbSBarry Smith /* 1143d382aafbSBarry Smith Routines for tracing memory corruption/bleeding with default PETSc 1144d382aafbSBarry Smith memory allocation 1145d382aafbSBarry Smith */ 1146d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocDump(FILE *); 1147d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocDumpLog(FILE *); 1148d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocGetCurrentUsage(PetscLogDouble *); 1149d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocGetMaximumUsage(PetscLogDouble *); 1150d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocDebug(PetscTruth); 1151d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocValidate(int,const char[],const char[],const char[]); 1152d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMallocSetDumpLog(void); 1153d382aafbSBarry Smith 1154d382aafbSBarry Smith 1155d382aafbSBarry Smith /* 1156d382aafbSBarry Smith Variable type where we stash PETSc object pointers in Fortran. 1157d382aafbSBarry Smith On most machines size(pointer) == sizeof(long) - except windows 1158d382aafbSBarry Smith where its sizeof(long long) 1159d382aafbSBarry Smith */ 1160d382aafbSBarry Smith 1161d382aafbSBarry Smith #if (PETSC_SIZEOF_VOID_P) == (PETSC_SIZEOF_LONG) 1162d382aafbSBarry Smith #define PetscFortranAddr long 1163d382aafbSBarry Smith #elif (PETSC_SIZEOF_VOID_P) == (PETSC_SIZEOF_LONG_LONG) 1164d382aafbSBarry Smith #define PetscFortranAddr long long 1165d382aafbSBarry Smith #else 1166d382aafbSBarry Smith #error "Unknown size for PetscFortranAddr! Send us a bugreport at petsc-maint@mcs.anl.gov" 1167d382aafbSBarry Smith #endif 1168d382aafbSBarry Smith 1169d382aafbSBarry Smith /*E 1170d382aafbSBarry Smith PetscDataType - Used for handling different basic data types. 1171d382aafbSBarry Smith 1172d382aafbSBarry Smith Level: beginner 1173d382aafbSBarry Smith 1174d382aafbSBarry Smith Developer comment: It would be nice if we could always just use MPI Datatypes, why can we not? 1175d382aafbSBarry Smith 1176d382aafbSBarry Smith .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(), 1177d382aafbSBarry Smith PetscDataTypeGetSize() 1178d382aafbSBarry Smith 1179d382aafbSBarry Smith E*/ 1180d382aafbSBarry Smith typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2, PETSC_LONG = 3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5, 1181d382aafbSBarry Smith PETSC_CHAR = 6,PETSC_LOGICAL = 7,PETSC_ENUM = 8,PETSC_TRUTH=9, PETSC_LONG_DOUBLE = 10, PETSC_QD_DD = 11} PetscDataType; 1182d382aafbSBarry Smith extern const char *PetscDataTypes[]; 1183d382aafbSBarry Smith 1184d382aafbSBarry Smith #if defined(PETSC_USE_COMPLEX) 1185d382aafbSBarry Smith #define PETSC_SCALAR PETSC_COMPLEX 1186d382aafbSBarry Smith #else 1187d382aafbSBarry Smith #if defined(PETSC_USE_SCALAR_SINGLE) 1188d382aafbSBarry Smith #define PETSC_SCALAR PETSC_FLOAT 1189d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_LONG_DOUBLE) 1190d382aafbSBarry Smith #define PETSC_SCALAR PETSC_LONG_DOUBLE 1191d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_INT) 1192d382aafbSBarry Smith #define PETSC_SCALAR PETSC_INT 1193d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_QD_DD) 1194d382aafbSBarry Smith #define PETSC_SCALAR PETSC_QD_DD 1195d382aafbSBarry Smith #else 1196d382aafbSBarry Smith #define PETSC_SCALAR PETSC_DOUBLE 1197d382aafbSBarry Smith #endif 1198d382aafbSBarry Smith #endif 1199d382aafbSBarry Smith #if defined(PETSC_USE_SCALAR_SINGLE) 1200d382aafbSBarry Smith #define PETSC_REAL PETSC_FLOAT 1201d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_LONG_DOUBLE) 1202d382aafbSBarry Smith #define PETSC_REAL PETSC_LONG_DOUBLE 1203d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_INT) 1204d382aafbSBarry Smith #define PETSC_REAL PETSC_INT 1205d382aafbSBarry Smith #elif defined(PETSC_USE_SCALAR_QD_DD) 1206d382aafbSBarry Smith #define PETSC_REAL PETSC_QD_DD 1207d382aafbSBarry Smith #else 1208d382aafbSBarry Smith #define PETSC_REAL PETSC_DOUBLE 1209d382aafbSBarry Smith #endif 1210d382aafbSBarry Smith #define PETSC_FORTRANADDR PETSC_LONG 1211d382aafbSBarry Smith 1212d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*); 1213d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMPIDataTypeToPetscDataType(MPI_Datatype,PetscDataType*); 1214d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDataTypeGetSize(PetscDataType,size_t*); 1215d382aafbSBarry Smith 1216d382aafbSBarry Smith /* 1217d382aafbSBarry Smith Basic memory and string operations. These are usually simple wrappers 1218d382aafbSBarry Smith around the basic Unix system calls, but a few of them have additional 1219d382aafbSBarry Smith functionality and/or error checking. 1220d382aafbSBarry Smith */ 1221d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBitMemcpy(void*,PetscInt,const void*,PetscInt,PetscInt,PetscDataType); 1222d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemmove(void*,void *,size_t); 1223d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemcmp(const void*,const void*,size_t,PetscTruth *); 1224d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrlen(const char[],size_t*); 1225d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrcmp(const char[],const char[],PetscTruth *); 1226d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrgrt(const char[],const char[],PetscTruth *); 1227d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrcasecmp(const char[],const char[],PetscTruth*); 1228d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrncmp(const char[],const char[],size_t,PetscTruth*); 1229d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrcpy(char[],const char[]); 1230d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrcat(char[],const char[]); 1231d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrncat(char[],const char[],size_t); 1232d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrncpy(char[],const char[],size_t); 1233d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrchr(const char[],char,char *[]); 1234d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrtolower(char[]); 1235d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrrchr(const char[],char,char *[]); 1236d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrstr(const char[],const char[],char *[]); 1237d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrrstr(const char[],const char[],char *[]); 1238d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrallocpy(const char[],char *[]); 1239d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStrreplace(MPI_Comm,const char[],char[],size_t); 1240d382aafbSBarry Smith #define PetscStrfree(a) ((a) ? PetscFree(a) : 0) 1241d382aafbSBarry Smith 1242d382aafbSBarry Smith 1243d382aafbSBarry Smith /*S 1244d382aafbSBarry Smith PetscToken - 'Token' used for managing tokenizing strings 1245d382aafbSBarry Smith 1246d382aafbSBarry Smith Level: intermediate 1247d382aafbSBarry Smith 1248d382aafbSBarry Smith .seealso: PetscTokenCreate(), PetscTokenFind(), PetscTokenDestroy() 1249d382aafbSBarry Smith S*/ 1250d382aafbSBarry Smith typedef struct _p_PetscToken* PetscToken; 1251d382aafbSBarry Smith 1252d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTokenCreate(const char[],const char,PetscToken*); 1253d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTokenFind(PetscToken,char *[]); 1254d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTokenDestroy(PetscToken); 1255d382aafbSBarry Smith 1256d382aafbSBarry Smith /* 1257d382aafbSBarry Smith These are MPI operations for MPI_Allreduce() etc 1258d382aafbSBarry Smith */ 1259d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT MPI_Op PetscMaxSum_Op; 1260d382aafbSBarry Smith #if defined(PETSC_USE_COMPLEX) && !defined(PETSC_HAVE_MPI_C_DOUBLE_COMPLEX) 1261d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT MPI_Op MPIU_SUM; 1262d382aafbSBarry Smith #else 1263d382aafbSBarry Smith #define MPIU_SUM MPI_SUM 1264d382aafbSBarry Smith #endif 1265d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMaxSum(MPI_Comm,const PetscInt[],PetscInt*,PetscInt*); 1266d382aafbSBarry Smith 1267d382aafbSBarry Smith /*S 1268d382aafbSBarry Smith PetscObject - any PETSc object, PetscViewer, Mat, Vec, KSP etc 1269d382aafbSBarry Smith 1270d382aafbSBarry Smith Level: beginner 1271d382aafbSBarry Smith 1272d382aafbSBarry Smith Note: This is the base class from which all objects appear. 1273d382aafbSBarry Smith 12741890ba74SBarry Smith .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName(), PetscObjectReference(), PetscObjectDereferenc() 1275d382aafbSBarry Smith S*/ 1276d382aafbSBarry Smith typedef struct _p_PetscObject* PetscObject; 1277d382aafbSBarry Smith 1278d382aafbSBarry Smith /*S 1279d382aafbSBarry Smith PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed 1280d382aafbSBarry Smith by string name 1281d382aafbSBarry Smith 1282d382aafbSBarry Smith Level: advanced 1283d382aafbSBarry Smith 1284d382aafbSBarry Smith .seealso: PetscFListAdd(), PetscFListDestroy() 1285d382aafbSBarry Smith S*/ 1286d382aafbSBarry Smith typedef struct _n_PetscFList *PetscFList; 1287d382aafbSBarry Smith 1288d382aafbSBarry Smith /*E 1289d382aafbSBarry Smith PetscFileMode - Access mode for a file. 1290d382aafbSBarry Smith 1291d382aafbSBarry Smith Level: beginner 1292d382aafbSBarry Smith 1293d382aafbSBarry Smith FILE_MODE_READ - open a file at its beginning for reading 1294d382aafbSBarry Smith 1295d382aafbSBarry Smith FILE_MODE_WRITE - open a file at its beginning for writing (will create if the file does not exist) 1296d382aafbSBarry Smith 1297d382aafbSBarry Smith FILE_MODE_APPEND - open a file at end for writing 1298d382aafbSBarry Smith 1299d382aafbSBarry Smith FILE_MODE_UPDATE - open a file for updating, meaning for reading and writing 1300d382aafbSBarry Smith 1301d382aafbSBarry Smith FILE_MODE_APPEND_UPDATE - open a file for updating, meaning for reading and writing, at the end 1302d382aafbSBarry Smith 1303d382aafbSBarry Smith .seealso: PetscViewerFileSetMode() 1304d382aafbSBarry Smith E*/ 1305d382aafbSBarry Smith typedef enum {FILE_MODE_READ, FILE_MODE_WRITE, FILE_MODE_APPEND, FILE_MODE_UPDATE, FILE_MODE_APPEND_UPDATE} PetscFileMode; 1306d382aafbSBarry Smith 1307d382aafbSBarry Smith #include "petscviewer.h" 1308d382aafbSBarry Smith #include "petscoptions.h" 1309d382aafbSBarry Smith 1310d382aafbSBarry Smith #define PETSC_SMALLEST_COOKIE 1211211 1311d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscCookie PETSC_LARGEST_COOKIE; 1312d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscCookie PETSC_OBJECT_COOKIE; 1313d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscCookieRegister(const char[],PetscCookie *); 1314d382aafbSBarry Smith 1315d382aafbSBarry Smith /* 1316d382aafbSBarry Smith Routines that get memory usage information from the OS 1317d382aafbSBarry Smith */ 1318d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemoryGetCurrentUsage(PetscLogDouble *); 1319d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemoryGetMaximumUsage(PetscLogDouble *); 1320d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemorySetGetMaximumUsage(void); 1321d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMemoryShowUsage(PetscViewer,const char[]); 1322d382aafbSBarry Smith 1323d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInfoAllow(PetscTruth,const char []); 1324d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetTime(PetscLogDouble*); 1325d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetCPUTime(PetscLogDouble*); 1326d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSleep(PetscReal); 1327d382aafbSBarry Smith 1328d382aafbSBarry Smith /* 1329d382aafbSBarry Smith Initialization of PETSc 1330d382aafbSBarry Smith */ 1331d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInitialize(int*,char***,const char[],const char[]); 1332d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscInitialize,(int *argc,char ***args),(argc,args,PETSC_NULL,PETSC_NULL)) 1333d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInitializeNoArguments(void); 1334d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInitialized(PetscTruth *); 1335d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFinalized(PetscTruth *); 1336d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFinalize(void); 1337d382aafbSBarry Smith EXTERN PetscErrorCode PetscInitializeFortran(void); 1338d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetArgs(int*,char ***); 1339d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetArguments(char ***); 1340d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFreeArguments(char **); 1341d382aafbSBarry Smith 1342d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscEnd(void); 1343d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscInitializePackage(const char[]); 1344d382aafbSBarry Smith 1345d382aafbSBarry Smith extern MPI_Comm PETSC_COMM_LOCAL_WORLD; 1346d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPMerge(PetscMPIInt,PetscErrorCode (*)(void*),void*); 1347d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPSpawn(PetscMPIInt); 1348d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPFinalize(void); 1349d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPRun(MPI_Comm,PetscErrorCode (*)(MPI_Comm,void *),void*); 1350d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPRunCtx(MPI_Comm,PetscErrorCode (*)(MPI_Comm,void*,void *),void*); 1351d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPFree(MPI_Comm,void*); 1352d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenMPMalloc(MPI_Comm,size_t,void**); 1353d382aafbSBarry Smith 1354d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPythonInitialize(const char[],const char[]); 1355d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPythonFinalize(void); 1356d382aafbSBarry Smith 1357d382aafbSBarry Smith /* 1358d382aafbSBarry Smith These are so that in extern C code we can caste function pointers to non-extern C 1359d382aafbSBarry Smith function pointers. Since the regular C++ code expects its function pointers to be 1360d382aafbSBarry Smith C++. 1361d382aafbSBarry Smith */ 1362d382aafbSBarry Smith typedef void (**PetscVoidStarFunction)(void); 1363d382aafbSBarry Smith typedef void (*PetscVoidFunction)(void); 1364d382aafbSBarry Smith typedef PetscErrorCode (*PetscErrorCodeFunction)(void); 1365d382aafbSBarry Smith 1366d382aafbSBarry Smith /* 1367d382aafbSBarry Smith PetscTryMethod - Queries an object for a method, if it exists then calls it. 1368d382aafbSBarry Smith These are intended to be used only inside PETSc functions. 1369d382aafbSBarry Smith */ 1370d382aafbSBarry Smith #define PetscTryMethod(obj,A,B,C) \ 1371d382aafbSBarry Smith 0;{ PetscErrorCode (*f)B, __ierr; \ 1372d382aafbSBarry Smith __ierr = PetscObjectQueryFunction((PetscObject)obj,A,(PetscVoidStarFunction)&f);CHKERRQ(__ierr); \ 1373d382aafbSBarry Smith if (f) {__ierr = (*f)C;CHKERRQ(__ierr);}\ 1374d382aafbSBarry Smith } 1375d382aafbSBarry Smith #define PetscUseMethod(obj,A,B,C) \ 1376d382aafbSBarry Smith 0;{ PetscErrorCode (*f)B, __ierr; \ 1377d382aafbSBarry Smith __ierr = PetscObjectQueryFunction((PetscObject)obj,A,(PetscVoidStarFunction)&f);CHKERRQ(__ierr); \ 1378d382aafbSBarry Smith if (f) {__ierr = (*f)C;CHKERRQ(__ierr);}\ 1379d382aafbSBarry Smith else {SETERRQ1(PETSC_ERR_SUP,"Cannot locate function %s in object",A);} \ 1380d382aafbSBarry Smith } 1381d382aafbSBarry Smith /* 1382d382aafbSBarry Smith Functions that can act on any PETSc object. 1383d382aafbSBarry Smith */ 1384d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectCreate(MPI_Comm,PetscObject*); 1385d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectCreateGeneric(MPI_Comm, PetscCookie, const char [], PetscObject *); 1386d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectDestroy(PetscObject); 1387d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetComm(PetscObject,MPI_Comm *); 1388d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetCookie(PetscObject,PetscCookie *); 1389d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetType(PetscObject,const char []); 1390d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetType(PetscObject,const char *[]); 1391d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetName(PetscObject,const char[]); 1392d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetName(PetscObject,const char*[]); 1393d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetTabLevel(PetscObject,PetscInt); 1394d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetTabLevel(PetscObject,PetscInt*); 1395d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectIncrementTabLevel(PetscObject,PetscObject,PetscInt); 1396d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectReference(PetscObject); 1397d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetReference(PetscObject,PetscInt*); 1398d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectDereference(PetscObject); 1399d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetNewTag(PetscObject,PetscMPIInt *); 1400d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectView(PetscObject,PetscViewer); 1401d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectCompose(PetscObject,const char[],PetscObject); 1402d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectQuery(PetscObject,const char[],PetscObject *); 1403d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)(void)); 1404d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetFromOptions(PetscObject); 1405d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetUp(PetscObject); 1406d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscCommGetNewTag(MPI_Comm,PetscMPIInt *); 1407d382aafbSBarry Smith 1408d382aafbSBarry Smith /*MC 1409d382aafbSBarry Smith PetscObjectComposeFunctionDynamic - Associates a function with a given PETSc object. 1410d382aafbSBarry Smith 1411*eca87e8dSBarry Smith Synopsis: 1412*eca87e8dSBarry Smith PetscErrorCode PetscObjectComposeFunctionDynamic(PetscObject obj,const char name[],const char fname[],void *ptr) 1413*eca87e8dSBarry Smith 1414d382aafbSBarry Smith Collective on PetscObject 1415d382aafbSBarry Smith 1416d382aafbSBarry Smith Input Parameters: 1417d382aafbSBarry Smith + obj - the PETSc object; this must be cast with a (PetscObject), for example, 1418d382aafbSBarry Smith PetscObjectCompose((PetscObject)mat,...); 1419d382aafbSBarry Smith . name - name associated with the child function 1420d382aafbSBarry Smith . fname - name of the function 1421d382aafbSBarry Smith - ptr - function pointer (or PETSC_NULL if using dynamic libraries) 1422d382aafbSBarry Smith 1423d382aafbSBarry Smith Level: advanced 1424d382aafbSBarry Smith 1425d382aafbSBarry Smith 1426d382aafbSBarry Smith Notes: 1427d382aafbSBarry Smith To remove a registered routine, pass in a PETSC_NULL rname and fnc(). 1428d382aafbSBarry Smith 1429d382aafbSBarry Smith PetscObjectComposeFunctionDynamic() can be used with any PETSc object (such as 1430d382aafbSBarry Smith Mat, Vec, KSP, SNES, etc.) or any user-provided object. 1431d382aafbSBarry Smith 1432d382aafbSBarry Smith The composed function must be wrapped in a EXTERN_C_BEGIN/END for this to 1433d382aafbSBarry Smith work in C++/complex with dynamic link libraries (config/configure.py options --with-shared --with-dynamic) 1434d382aafbSBarry Smith enabled. 1435d382aafbSBarry Smith 1436d382aafbSBarry Smith Concepts: objects^composing functions 1437d382aafbSBarry Smith Concepts: composing functions 1438d382aafbSBarry Smith Concepts: functions^querying 1439d382aafbSBarry Smith Concepts: objects^querying 1440d382aafbSBarry Smith Concepts: querying objects 1441d382aafbSBarry Smith 1442d382aafbSBarry Smith .seealso: PetscObjectQueryFunction() 1443d382aafbSBarry Smith M*/ 1444d382aafbSBarry Smith #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 1445d382aafbSBarry Smith #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0) 1446d382aafbSBarry Smith #else 1447d382aafbSBarry Smith #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(PetscVoidFunction)(d)) 1448d382aafbSBarry Smith #endif 1449d382aafbSBarry Smith 1450d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectQueryFunction(PetscObject,const char[],void (**)(void)); 1451d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectSetOptionsPrefix(PetscObject,const char[]); 1452d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 1453d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectPrependOptionsPrefix(PetscObject,const char[]); 1454d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectGetOptionsPrefix(PetscObject,const char*[]); 1455d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectPublish(PetscObject); 1456d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectChangeTypeName(PetscObject,const char[]); 1457d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectRegisterDestroy(PetscObject); 1458d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectRegisterDestroyAll(void); 1459d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscObjectName(PetscObject); 1460d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTypeCompare(PetscObject,const char[],PetscTruth*); 1461d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRegisterFinalize(PetscErrorCode (*)(void)); 1462d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRegisterFinalizeAll(void); 1463d382aafbSBarry Smith 1464d382aafbSBarry Smith /* 1465d382aafbSBarry Smith Defines PETSc error handling. 1466d382aafbSBarry Smith */ 1467d382aafbSBarry Smith #include "petscerror.h" 1468d382aafbSBarry Smith 1469d382aafbSBarry Smith /*S 1470d382aafbSBarry Smith PetscOList - Linked list of PETSc objects, accessable by string name 1471d382aafbSBarry Smith 14721d0fab5eSBarry Smith Level: developer 1473d382aafbSBarry Smith 14741d0fab5eSBarry Smith Notes: Used by PetscObjectCompose() and PetscObjectQuery() 14751d0fab5eSBarry Smith 14761d0fab5eSBarry Smith .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind(), PetscObjectCompose(), PetscObjectQuery() 1477d382aafbSBarry Smith S*/ 1478d382aafbSBarry Smith typedef struct _n_PetscOList *PetscOList; 1479d382aafbSBarry Smith 1480d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListDestroy(PetscOList); 1481d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListFind(PetscOList,const char[],PetscObject*); 1482d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListReverseFind(PetscOList,PetscObject,char**); 1483d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListAdd(PetscOList *,const char[],PetscObject); 1484d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOListDuplicate(PetscOList,PetscOList *); 1485d382aafbSBarry Smith 1486d382aafbSBarry Smith /* 1487d382aafbSBarry Smith Dynamic library lists. Lists of names of routines in dynamic 1488d382aafbSBarry Smith link libraries that will be loaded as needed. 1489d382aafbSBarry Smith */ 1490d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void)); 1491d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListDestroy(PetscFList*); 1492d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListFind(PetscFList,MPI_Comm,const char[],void (**)(void)); 1493d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],const char[],const char[],PetscFList,const char[]); 1494d382aafbSBarry Smith #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 1495d382aafbSBarry Smith #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0) 1496d382aafbSBarry Smith #else 1497d382aafbSBarry Smith #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c) 1498d382aafbSBarry Smith #endif 1499d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListDuplicate(PetscFList,PetscFList *); 1500d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListView(PetscFList,PetscViewer); 1501d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListConcat(const char [],const char [],char []); 1502d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFListGet(PetscFList,char ***,int*); 1503d382aafbSBarry Smith 1504d382aafbSBarry Smith /*S 1505d382aafbSBarry Smith PetscDLLibrary - Linked list of dynamics libraries to search for functions 1506d382aafbSBarry Smith 1507d382aafbSBarry Smith Level: advanced 1508d382aafbSBarry Smith 1509d382aafbSBarry Smith --with-shared --with-dynamic must be used with config/configure.py to use dynamic libraries 1510d382aafbSBarry Smith 1511d382aafbSBarry Smith .seealso: PetscDLLibraryOpen() 1512d382aafbSBarry Smith S*/ 1513d382aafbSBarry Smith typedef struct _n_PetscDLLibrary *PetscDLLibrary; 1514d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscDLLibrary DLLibrariesLoaded; 1515d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryAppend(MPI_Comm,PetscDLLibrary *,const char[]); 1516d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryPrepend(MPI_Comm,PetscDLLibrary *,const char[]); 1517d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibrarySym(MPI_Comm,PetscDLLibrary *,const char[],const char[],void **); 1518d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryPrintPath(PetscDLLibrary); 1519d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,size_t,PetscTruth *); 1520d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryOpen(MPI_Comm,const char[],PetscDLLibrary *); 1521d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryClose(PetscDLLibrary); 1522d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscDLLibraryCCAAppend(MPI_Comm,PetscDLLibrary *,const char[]); 1523d382aafbSBarry Smith 1524d382aafbSBarry Smith /* 1525d382aafbSBarry Smith Useful utility routines 1526d382aafbSBarry Smith */ 1527d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSplitOwnership(MPI_Comm,PetscInt*,PetscInt*); 1528d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSplitOwnershipBlock(MPI_Comm,PetscInt,PetscInt*,PetscInt*); 1529d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSequentialPhaseBegin(MPI_Comm,PetscMPIInt); 1530d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscSequentialPhaseBegin,(MPI_Comm comm),(comm,1)) 1531d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscSequentialPhaseBegin,(void),(PETSC_COMM_WORLD,1)) 1532d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSequentialPhaseEnd(MPI_Comm,PetscMPIInt); 1533d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscSequentialPhaseEnd,(MPI_Comm comm),(comm,1)) 1534d382aafbSBarry Smith PetscPolymorphicSubroutine(PetscSequentialPhaseEnd,(void),(PETSC_COMM_WORLD,1)) 1535d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBarrier(PetscObject); 1536d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscMPIDump(FILE*); 1537d382aafbSBarry Smith 1538d382aafbSBarry Smith #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE) 1539d382aafbSBarry Smith /* 1540d382aafbSBarry Smith Defines basic graphics available from PETSc. 1541d382aafbSBarry Smith */ 1542d382aafbSBarry Smith #include "petscdraw.h" 1543d382aafbSBarry Smith 1544d382aafbSBarry Smith /* 1545d382aafbSBarry Smith Defines the base data structures for all PETSc objects 1546d382aafbSBarry Smith */ 1547d382aafbSBarry Smith #include "private/petscimpl.h" 1548d382aafbSBarry Smith /* 1549d382aafbSBarry Smith Defines PETSc profiling. 1550d382aafbSBarry Smith */ 1551d382aafbSBarry Smith #include "petsclog.h" 1552d382aafbSBarry Smith 15536c7e564aSBarry Smith 1554d382aafbSBarry Smith /* 1555d382aafbSBarry Smith For locking, unlocking and destroying AMS memories associated with 1556d382aafbSBarry Smith PETSc objects. Not currently used. 1557d382aafbSBarry Smith */ 1558d382aafbSBarry Smith #define PetscPublishAll(v) 0 1559d382aafbSBarry Smith #define PetscObjectTakeAccess(obj) 0 1560d382aafbSBarry Smith #define PetscObjectGrantAccess(obj) 0 1561d382aafbSBarry Smith #define PetscObjectDepublish(obj) 0 1562d382aafbSBarry Smith 1563d382aafbSBarry Smith /* 1564d382aafbSBarry Smith Simple PETSc parallel IO for ASCII printing 1565d382aafbSBarry Smith */ 1566d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFixFilename(const char[],char[]); 1567d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFOpen(MPI_Comm,const char[],const char[],FILE**); 1568d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFClose(MPI_Comm,FILE*); 1569d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 1570d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 1571d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSNPrintf(char*,size_t,const char [],...); 1572d382aafbSBarry Smith 1573d382aafbSBarry Smith /* These are used internally by PETSc ASCII IO routines*/ 1574d382aafbSBarry Smith #include <stdarg.h> 1575d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscVSNPrintf(char*,size_t,const char[],int*,va_list); 1576d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT (*PetscVFPrintf)(FILE*,const char[],va_list); 1577d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscVFPrintfDefault(FILE*,const char[],va_list); 1578d382aafbSBarry Smith 1579d382aafbSBarry Smith /*MC 1580d382aafbSBarry Smith PetscErrorPrintf - Prints error messages. 1581d382aafbSBarry Smith 1582d382aafbSBarry Smith Synopsis: 1583d382aafbSBarry Smith PetscErrorCode (*PetscErrorPrintf)(const char format[],...); 1584d382aafbSBarry Smith 1585*eca87e8dSBarry Smith Not Collective 1586*eca87e8dSBarry Smith 1587d382aafbSBarry Smith Input Parameters: 1588d382aafbSBarry Smith . format - the usual printf() format string 1589d382aafbSBarry Smith 1590d382aafbSBarry Smith Options Database Keys: 1591d382aafbSBarry Smith + -error_output_stdout - cause error messages to be printed to stdout instead of the 1592d382aafbSBarry Smith (default) stderr 1593d382aafbSBarry Smith - -error_output_none to turn off all printing of error messages (does not change the way the 1594d382aafbSBarry Smith error is handled.) 1595d382aafbSBarry Smith 1596d382aafbSBarry Smith Notes: Use 1597d382aafbSBarry Smith $ PetscErrorPrintf = PetscErrorPrintfNone; to turn off all printing of error messages (does not change the way the 1598d382aafbSBarry Smith $ error is handled.) and 1599d382aafbSBarry Smith $ PetscErrorPrintf = PetscErrorPrintfDefault; to turn it back on 1600d382aafbSBarry Smith 1601d382aafbSBarry Smith Use 1602d382aafbSBarry Smith PETSC_STDERR = FILE* obtained from a file open etc. to have stderr printed to the file. 1603d382aafbSBarry Smith PETSC_STDOUT = FILE* obtained from a file open etc. to have stdout printed to the file. 1604d382aafbSBarry Smith 1605d382aafbSBarry Smith Use 1606d382aafbSBarry Smith PetscPushErrorHandler() to provide your own error handler that determines what kind of messages to print 1607d382aafbSBarry Smith 1608d382aafbSBarry Smith Level: developer 1609d382aafbSBarry Smith 1610d382aafbSBarry Smith Fortran Note: 1611d382aafbSBarry Smith This routine is not supported in Fortran. 1612d382aafbSBarry Smith 1613d382aafbSBarry Smith Concepts: error messages^printing 1614d382aafbSBarry Smith Concepts: printing^error messages 1615d382aafbSBarry Smith 1616d382aafbSBarry Smith .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscHelpPrintf(), PetscPrintf(), PetscErrorHandlerPush() 1617d382aafbSBarry Smith M*/ 1618d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT PetscErrorCode (*PetscErrorPrintf)(const char[],...); 1619d382aafbSBarry Smith 1620d382aafbSBarry Smith /*MC 1621d382aafbSBarry Smith PetscHelpPrintf - Prints help messages. 1622d382aafbSBarry Smith 1623d382aafbSBarry Smith Synopsis: 1624d382aafbSBarry Smith PetscErrorCode (*PetscHelpPrintf)(const char format[],...); 1625d382aafbSBarry Smith 1626*eca87e8dSBarry Smith Not Collective 1627*eca87e8dSBarry Smith 1628d382aafbSBarry Smith Input Parameters: 1629d382aafbSBarry Smith . format - the usual printf() format string 1630d382aafbSBarry Smith 1631d382aafbSBarry Smith Level: developer 1632d382aafbSBarry Smith 1633d382aafbSBarry Smith Fortran Note: 1634d382aafbSBarry Smith This routine is not supported in Fortran. 1635d382aafbSBarry Smith 1636d382aafbSBarry Smith Concepts: help messages^printing 1637d382aafbSBarry Smith Concepts: printing^help messages 1638d382aafbSBarry Smith 1639d382aafbSBarry Smith .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscErrorPrintf() 1640d382aafbSBarry Smith M*/ 1641d382aafbSBarry Smith EXTERN PETSC_DLLEXPORT PetscErrorCode (*PetscHelpPrintf)(MPI_Comm,const char[],...); 1642d382aafbSBarry Smith 1643d382aafbSBarry Smith EXTERN PetscErrorCode PetscErrorPrintfDefault(const char [],...); 1644d382aafbSBarry Smith EXTERN PetscErrorCode PetscErrorPrintfNone(const char [],...); 1645d382aafbSBarry Smith EXTERN PetscErrorCode PetscHelpPrintfDefault(MPI_Comm,const char [],...); 1646d382aafbSBarry Smith 1647d382aafbSBarry Smith #if defined(PETSC_HAVE_POPEN) 1648d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPOpen(MPI_Comm,const char[],const char[],const char[],FILE **); 1649d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPClose(MPI_Comm,FILE*); 1650d382aafbSBarry Smith #endif 1651d382aafbSBarry Smith 1652d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 1653d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 1654d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSynchronizedFlush(MPI_Comm); 1655d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSynchronizedFGets(MPI_Comm,FILE*,size_t,char[]); 1656d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStartMatlab(MPI_Comm,const char[],const char[],FILE**); 1657d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStartJava(MPI_Comm,const char[],const char[],FILE**); 1658d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetPetscDir(const char*[]); 1659d382aafbSBarry Smith 1660d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPopUpSelect(MPI_Comm,const char*,const char*,int,const char**,int*); 1661d382aafbSBarry Smith 1662d382aafbSBarry Smith /*S 1663d382aafbSBarry Smith PetscContainer - Simple PETSc object that contains a pointer to any required data 1664d382aafbSBarry Smith 1665d382aafbSBarry Smith Level: advanced 1666d382aafbSBarry Smith 1667d382aafbSBarry Smith .seealso: PetscObject, PetscContainerCreate() 1668d382aafbSBarry Smith S*/ 1669d382aafbSBarry Smith extern PetscCookie PETSC_DLLEXPORT PETSC_CONTAINER_COOKIE; 1670d382aafbSBarry Smith typedef struct _p_PetscContainer* PetscContainer; 1671d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerGetPointer(PetscContainer,void **); 1672d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerSetPointer(PetscContainer,void *); 1673d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerDestroy(PetscContainer); 1674d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerCreate(MPI_Comm,PetscContainer *); 1675d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscContainerSetUserDestroy(PetscContainer, PetscErrorCode (*)(void*)); 1676d382aafbSBarry Smith 1677d382aafbSBarry Smith /* 1678d382aafbSBarry Smith For use in debuggers 1679d382aafbSBarry Smith */ 1680d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscMPIInt PetscGlobalRank; 1681d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscMPIInt PetscGlobalSize; 1682d382aafbSBarry Smith 1683d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscIntView(PetscInt,const PetscInt[],PetscViewer); 1684d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRealView(PetscInt,const PetscReal[],PetscViewer); 1685d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscScalarView(PetscInt,const PetscScalar[],PetscViewer); 1686d382aafbSBarry Smith 1687d382aafbSBarry Smith #if defined(PETSC_HAVE_MEMORY_H) 1688d382aafbSBarry Smith #include <memory.h> 1689d382aafbSBarry Smith #endif 1690d382aafbSBarry Smith #if defined(PETSC_HAVE_STDLIB_H) 1691d382aafbSBarry Smith #include <stdlib.h> 1692d382aafbSBarry Smith #endif 1693d382aafbSBarry Smith #if defined(PETSC_HAVE_STRINGS_H) 1694d382aafbSBarry Smith #include <strings.h> 1695d382aafbSBarry Smith #endif 1696d382aafbSBarry Smith #if defined(PETSC_HAVE_STRING_H) 1697d382aafbSBarry Smith #include <string.h> 1698d382aafbSBarry Smith #endif 16996c7e564aSBarry Smith 17006c7e564aSBarry Smith 1701d382aafbSBarry Smith #if defined(PETSC_HAVE_XMMINTRIN_H) 1702d382aafbSBarry Smith #include <xmmintrin.h> 1703d382aafbSBarry Smith #endif 1704d382aafbSBarry Smith #if defined(PETSC_HAVE_STDINT_H) 1705d382aafbSBarry Smith #include <stdint.h> 1706d382aafbSBarry Smith #endif 1707d382aafbSBarry Smith 1708d382aafbSBarry Smith /*@C 1709d382aafbSBarry Smith PetscMemcpy - Copies n bytes, beginning at location b, to the space 1710d382aafbSBarry Smith beginning at location a. The two memory regions CANNOT overlap, use 1711d382aafbSBarry Smith PetscMemmove() in that case. 1712d382aafbSBarry Smith 1713d382aafbSBarry Smith Not Collective 1714d382aafbSBarry Smith 1715d382aafbSBarry Smith Input Parameters: 1716d382aafbSBarry Smith + b - pointer to initial memory space 1717d382aafbSBarry Smith - n - length (in bytes) of space to copy 1718d382aafbSBarry Smith 1719d382aafbSBarry Smith Output Parameter: 1720d382aafbSBarry Smith . a - pointer to copy space 1721d382aafbSBarry Smith 1722d382aafbSBarry Smith Level: intermediate 1723d382aafbSBarry Smith 1724d382aafbSBarry Smith Compile Option: 1725d382aafbSBarry Smith PETSC_PREFER_DCOPY_FOR_MEMCPY will cause the BLAS dcopy() routine to be used 1726d382aafbSBarry Smith for memory copies on double precision values. 1727d382aafbSBarry Smith PETSC_PREFER_COPY_FOR_MEMCPY will cause C code to be used 1728d382aafbSBarry Smith for memory copies on double precision values. 1729d382aafbSBarry Smith PETSC_PREFER_FORTRAN_FORMEMCPY will cause Fortran code to be used 1730d382aafbSBarry Smith for memory copies on double precision values. 1731d382aafbSBarry Smith 1732d382aafbSBarry Smith Note: 1733d382aafbSBarry Smith This routine is analogous to memcpy(). 1734d382aafbSBarry Smith 1735d382aafbSBarry Smith Concepts: memory^copying 1736d382aafbSBarry Smith Concepts: copying^memory 1737d382aafbSBarry Smith 1738d382aafbSBarry Smith .seealso: PetscMemmove() 1739d382aafbSBarry Smith 1740d382aafbSBarry Smith @*/ 1741d382aafbSBarry Smith PETSC_STATIC_INLINE PetscErrorCode PETSC_DLLEXPORT PetscMemcpy(void *a,const void *b,size_t n) 1742d382aafbSBarry Smith { 1743d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1744d382aafbSBarry Smith unsigned long al = (unsigned long) a,bl = (unsigned long) b; 1745d382aafbSBarry Smith unsigned long nl = (unsigned long) n; 1746d382aafbSBarry Smith if (n > 0 && !b) SETERRQ(PETSC_ERR_ARG_NULL,"Trying to copy from a null pointer"); 1747d382aafbSBarry Smith if (n > 0 && !a) SETERRQ(PETSC_ERR_ARG_NULL,"Trying to copy to a null pointer"); 1748d382aafbSBarry Smith #endif 1749d382aafbSBarry Smith PetscFunctionBegin; 1750d382aafbSBarry Smith if (a != b) { 1751d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1752d382aafbSBarry Smith if ((al > bl && (al - bl) < nl) || (bl - al) < nl) { 1753d382aafbSBarry Smith SETERRQ3(PETSC_ERR_ARG_INCOMP,"Memory regions overlap: either use PetscMemmov()\n\ 1754d382aafbSBarry Smith or make sure your copy regions and lengths are correct. \n\ 1755d382aafbSBarry Smith Length (bytes) %ld first address %ld second address %ld",nl,al,bl); 1756d382aafbSBarry Smith } 1757d382aafbSBarry Smith #endif 1758d382aafbSBarry Smith #if (defined(PETSC_PREFER_DCOPY_FOR_MEMCPY) || defined(PETSC_PREFER_COPY_FOR_MEMCPY) || defined(PETSC_PREFER_FORTRAN_FORMEMCPY)) 1759d382aafbSBarry Smith if (!(((long) a) % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) { 1760d382aafbSBarry Smith size_t len = n/sizeof(PetscScalar); 1761d382aafbSBarry Smith #if defined(PETSC_PREFER_DCOPY_FOR_MEMCPY) 1762d382aafbSBarry Smith PetscBLASInt one = 1,blen = PetscBLASIntCast(len); 1763d382aafbSBarry Smith BLAScopy_(&blen,(PetscScalar *)b,&one,(PetscScalar *)a,&one); 1764d382aafbSBarry Smith #elif defined(PETSC_PREFER_FORTRAN_FORMEMCPY) 1765d382aafbSBarry Smith fortrancopy_(&len,(PetscScalar*)b,(PetscScalar*)a); 1766d382aafbSBarry Smith #else 1767d382aafbSBarry Smith size_t i; 1768d382aafbSBarry Smith PetscScalar *x = (PetscScalar*)b, *y = (PetscScalar*)a; 1769d382aafbSBarry Smith for (i=0; i<len; i++) y[i] = x[i]; 1770d382aafbSBarry Smith #endif 1771d382aafbSBarry Smith } else { 1772d382aafbSBarry Smith memcpy((char*)(a),(char*)(b),n); 1773d382aafbSBarry Smith } 1774d382aafbSBarry Smith #elif defined(PETSC_HAVE__INTEL_FAST_MEMCPY) 1775d382aafbSBarry Smith _intel_fast_memcpy((char*)(a),(char*)(b),n); 1776d382aafbSBarry Smith #else 1777d382aafbSBarry Smith memcpy((char*)(a),(char*)(b),n); 1778d382aafbSBarry Smith #endif 1779d382aafbSBarry Smith } 1780d382aafbSBarry Smith PetscFunctionReturn(0); 1781d382aafbSBarry Smith } 1782d382aafbSBarry Smith 1783d382aafbSBarry Smith /*@C 1784d382aafbSBarry Smith PetscMemzero - Zeros the specified memory. 1785d382aafbSBarry Smith 1786d382aafbSBarry Smith Not Collective 1787d382aafbSBarry Smith 1788d382aafbSBarry Smith Input Parameters: 1789d382aafbSBarry Smith + a - pointer to beginning memory location 1790d382aafbSBarry Smith - n - length (in bytes) of memory to initialize 1791d382aafbSBarry Smith 1792d382aafbSBarry Smith Level: intermediate 1793d382aafbSBarry Smith 1794d382aafbSBarry Smith Compile Option: 1795d382aafbSBarry Smith PETSC_PREFER_BZERO - on certain machines (the IBM RS6000) the bzero() routine happens 1796d382aafbSBarry Smith to be faster than the memset() routine. This flag causes the bzero() routine to be used. 1797d382aafbSBarry Smith 1798d382aafbSBarry Smith Concepts: memory^zeroing 1799d382aafbSBarry Smith Concepts: zeroing^memory 1800d382aafbSBarry Smith 1801d382aafbSBarry Smith .seealso: PetscMemcpy() 1802d382aafbSBarry Smith @*/ 1803d382aafbSBarry Smith PETSC_STATIC_INLINE PetscErrorCode PETSC_DLLEXPORT PetscMemzero(void *a,size_t n) 1804d382aafbSBarry Smith { 1805d382aafbSBarry Smith if (n > 0) { 1806d382aafbSBarry Smith #if defined(PETSC_USE_DEBUG) 1807d382aafbSBarry Smith if (!a) SETERRQ(PETSC_ERR_ARG_NULL,"Trying to zero at a null pointer"); 1808d382aafbSBarry Smith #endif 1809d382aafbSBarry Smith #if defined(PETSC_PREFER_ZERO_FOR_MEMZERO) 1810d382aafbSBarry Smith if (!(((long) a) % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) { 1811d382aafbSBarry Smith size_t i,len = n/sizeof(PetscScalar); 1812d382aafbSBarry Smith PetscScalar *x = (PetscScalar*)a; 1813d382aafbSBarry Smith for (i=0; i<len; i++) x[i] = 0.0; 1814d382aafbSBarry Smith } else { 1815d382aafbSBarry Smith #elif defined(PETSC_PREFER_FORTRAN_FOR_MEMZERO) 1816d382aafbSBarry Smith if (!(((long) a) % sizeof(PetscScalar)) && !(n % sizeof(PetscScalar))) { 1817d382aafbSBarry Smith PetscInt len = n/sizeof(PetscScalar); 1818d382aafbSBarry Smith fortranzero_(&len,(PetscScalar*)a); 1819d382aafbSBarry Smith } else { 1820d382aafbSBarry Smith #endif 1821d382aafbSBarry Smith #if defined(PETSC_PREFER_BZERO) 1822d382aafbSBarry Smith bzero((char *)a,n); 1823d382aafbSBarry Smith #elif defined (PETSC_HAVE__INTEL_FAST_MEMSET) 1824d382aafbSBarry Smith _intel_fast_memset((char*)a,0,n); 1825d382aafbSBarry Smith #else 1826d382aafbSBarry Smith memset((char*)a,0,n); 1827d382aafbSBarry Smith #endif 1828d382aafbSBarry Smith #if defined(PETSC_PREFER_ZERO_FOR_MEMZERO) || defined(PETSC_PREFER_FORTRAN_FOR_MEMZERO) 1829d382aafbSBarry Smith } 1830d382aafbSBarry Smith #endif 1831d382aafbSBarry Smith } 1832d382aafbSBarry Smith return 0; 1833d382aafbSBarry Smith } 1834d382aafbSBarry Smith 1835d382aafbSBarry Smith /*MC 1836d382aafbSBarry Smith PetscPrefetchBlock - Prefetches a block of memory 1837d382aafbSBarry Smith 1838*eca87e8dSBarry Smith Synopsis: 1839*eca87e8dSBarry Smith void PetscPrefetchBlock(const anytype *a,size_t n,int rw,int t) 1840*eca87e8dSBarry Smith 1841d382aafbSBarry Smith Not Collective 1842d382aafbSBarry Smith 1843d382aafbSBarry Smith Input Parameters: 1844d382aafbSBarry Smith + a - pointer to first element to fetch (any type but usually PetscInt or PetscScalar) 1845d382aafbSBarry Smith . n - number of elements to fetch 1846d382aafbSBarry Smith . rw - 1 if the memory will be written to, otherwise 0 (ignored by many processors) 1847d382aafbSBarry Smith - t - temporal locality (0,1,2,3), see note 1848d382aafbSBarry Smith 1849d382aafbSBarry Smith Level: developer 1850d382aafbSBarry Smith 1851d382aafbSBarry Smith Notes: 1852d382aafbSBarry Smith The last two arguments (rw and t) must be compile-time constants. 1853d382aafbSBarry Smith 1854d382aafbSBarry Smith There are four levels of temporal locality (not all architectures distinguish) 1855d382aafbSBarry Smith + 0 - Non-temporal. Prefetches directly to L1, evicts to memory (skips higher level cache unless it was already there when prefetched). 1856d382aafbSBarry 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. 1857d382aafbSBarry Smith . 2 - Same as 1, but keep in mid-level cache. (On most systems, 1 and 2 are equivalent.) 1858d382aafbSBarry 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. 1859d382aafbSBarry Smith 1860d382aafbSBarry Smith This function does nothing on architectures that do not support prefetch and never errors (even if passed an invalid 1861d382aafbSBarry Smith address). 1862d382aafbSBarry Smith 1863d382aafbSBarry Smith Concepts: memory 1864d382aafbSBarry Smith M*/ 1865d382aafbSBarry Smith #define PetscPrefetchBlock(a,n,rw,t) do { \ 1866d382aafbSBarry Smith const char *_p = (const char*)(a),*_end = (const char*)((a)+(n)); \ 1867d382aafbSBarry Smith for ( ; _p < _end; _p += PETSC_LEVEL1_DCACHE_LINESIZE) PETSC_Prefetch(_p,(rw),(t)); \ 1868d382aafbSBarry Smith } while (0) 1869d382aafbSBarry Smith 1870d382aafbSBarry Smith /* 1871d382aafbSBarry Smith Allows accessing Matlab Engine 1872d382aafbSBarry Smith */ 1873d382aafbSBarry Smith #include "petscmatlab.h" 1874d382aafbSBarry Smith 1875d382aafbSBarry Smith /* 1876d382aafbSBarry Smith Determine if some of the kernel computation routines use 1877d382aafbSBarry Smith Fortran (rather than C) for the numerical calculations. On some machines 1878d382aafbSBarry Smith and compilers (like complex numbers) the Fortran version of the routines 1879d382aafbSBarry Smith is faster than the C/C++ versions. The flag --with-fortran-kernels 1880d382aafbSBarry Smith should be used with config/configure.py to turn these on. 1881d382aafbSBarry Smith */ 1882d382aafbSBarry Smith #if defined(PETSC_USE_FORTRAN_KERNELS) 1883d382aafbSBarry Smith 1884d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTCRL) 1885d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTCRL 1886d382aafbSBarry Smith #endif 1887d382aafbSBarry Smith 1888d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTCSRPERM) 1889d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTCSRPERM 1890d382aafbSBarry Smith #endif 1891d382aafbSBarry Smith 1892d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 1893d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 1894d382aafbSBarry Smith #endif 1895d382aafbSBarry Smith 1896d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 1897d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 1898d382aafbSBarry Smith #endif 1899d382aafbSBarry Smith 1900d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM) 1901d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_NORM 1902d382aafbSBarry Smith #endif 1903d382aafbSBarry Smith 1904d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 1905d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MAXPY 1906d382aafbSBarry Smith #endif 1907d382aafbSBarry Smith 1908d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 1909d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 1910d382aafbSBarry Smith #endif 1911d382aafbSBarry Smith 1912d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 1913d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 1914d382aafbSBarry Smith #endif 1915d382aafbSBarry Smith 1916d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 1917d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 1918d382aafbSBarry Smith #endif 1919d382aafbSBarry Smith 1920d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 1921d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 1922d382aafbSBarry Smith #endif 1923d382aafbSBarry Smith 1924d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 1925d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_MDOT 1926d382aafbSBarry Smith #endif 1927d382aafbSBarry Smith 1928d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 1929d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 1930d382aafbSBarry Smith #endif 1931d382aafbSBarry Smith 1932d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX) 1933d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_AYPX 1934d382aafbSBarry Smith #endif 1935d382aafbSBarry Smith 1936d382aafbSBarry Smith #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY) 1937d382aafbSBarry Smith #define PETSC_USE_FORTRAN_KERNEL_WAXPY 1938d382aafbSBarry Smith #endif 1939d382aafbSBarry Smith 1940d382aafbSBarry Smith #endif 1941d382aafbSBarry Smith 1942d382aafbSBarry Smith /* 1943d382aafbSBarry Smith Macros for indicating code that should be compiled with a C interface, 1944d382aafbSBarry Smith rather than a C++ interface. Any routines that are dynamically loaded 1945d382aafbSBarry Smith (such as the PCCreate_XXX() routines) must be wrapped so that the name 1946d382aafbSBarry Smith mangler does not change the functions symbol name. This just hides the 1947d382aafbSBarry Smith ugly extern "C" {} wrappers. 1948d382aafbSBarry Smith */ 1949d382aafbSBarry Smith #if defined(__cplusplus) 1950d382aafbSBarry Smith #define EXTERN_C_BEGIN extern "C" { 1951d382aafbSBarry Smith #define EXTERN_C_END } 1952d382aafbSBarry Smith #else 1953d382aafbSBarry Smith #define EXTERN_C_BEGIN 1954d382aafbSBarry Smith #define EXTERN_C_END 1955d382aafbSBarry Smith #endif 1956d382aafbSBarry Smith 1957d382aafbSBarry Smith /* --------------------------------------------------------------------*/ 1958d382aafbSBarry Smith 1959d382aafbSBarry Smith /*MC 1960d382aafbSBarry Smith MPI_Comm - the basic object used by MPI to determine which processes are involved in a 1961d382aafbSBarry Smith communication 1962d382aafbSBarry Smith 1963d382aafbSBarry Smith Level: beginner 1964d382aafbSBarry Smith 1965d382aafbSBarry Smith Note: This manual page is a place-holder because MPICH does not have a manual page for MPI_Comm 1966d382aafbSBarry Smith 1967d382aafbSBarry Smith .seealso: PETSC_COMM_WORLD, PETSC_COMM_SELF 1968d382aafbSBarry Smith M*/ 1969d382aafbSBarry Smith 1970d382aafbSBarry Smith /*MC 1971d382aafbSBarry Smith PetscScalar - PETSc type that represents either a double precision real number, a double precision 1972d382aafbSBarry Smith complex number, a single precision real number, a long double or an int - if the code is configured 1973d382aafbSBarry Smith with --with-scalar-type=real,complex --with-precision=single,double,longdouble,int,matsingle 1974d382aafbSBarry Smith 1975d382aafbSBarry Smith 1976d382aafbSBarry Smith Level: beginner 1977d382aafbSBarry Smith 1978d382aafbSBarry Smith .seealso: PetscReal, PassiveReal, PassiveScalar, MPIU_SCALAR, PetscInt 1979d382aafbSBarry Smith M*/ 1980d382aafbSBarry Smith 1981d382aafbSBarry Smith /*MC 1982d382aafbSBarry Smith PetscReal - PETSc type that represents a real number version of PetscScalar 1983d382aafbSBarry Smith 1984d382aafbSBarry Smith Level: beginner 1985d382aafbSBarry Smith 1986d382aafbSBarry Smith .seealso: PetscScalar, PassiveReal, PassiveScalar 1987d382aafbSBarry Smith M*/ 1988d382aafbSBarry Smith 1989d382aafbSBarry Smith /*MC 1990d382aafbSBarry Smith PassiveScalar - PETSc type that represents a PetscScalar 1991d382aafbSBarry Smith Level: beginner 1992d382aafbSBarry Smith 1993d382aafbSBarry Smith This is the same as a PetscScalar except in code that is automatically differentiated it is 1994d382aafbSBarry Smith treated as a constant (not an indendent or dependent variable) 1995d382aafbSBarry Smith 1996d382aafbSBarry Smith .seealso: PetscReal, PassiveReal, PetscScalar 1997d382aafbSBarry Smith M*/ 1998d382aafbSBarry Smith 1999d382aafbSBarry Smith /*MC 2000d382aafbSBarry Smith PassiveReal - PETSc type that represents a PetscReal 2001d382aafbSBarry Smith 2002d382aafbSBarry Smith Level: beginner 2003d382aafbSBarry Smith 2004d382aafbSBarry Smith This is the same as a PetscReal except in code that is automatically differentiated it is 2005d382aafbSBarry Smith treated as a constant (not an indendent or dependent variable) 2006d382aafbSBarry Smith 2007d382aafbSBarry Smith .seealso: PetscScalar, PetscReal, PassiveScalar 2008d382aafbSBarry Smith M*/ 2009d382aafbSBarry Smith 2010d382aafbSBarry Smith /*MC 2011d382aafbSBarry Smith MPIU_SCALAR - MPI datatype corresponding to PetscScalar 2012d382aafbSBarry Smith 2013d382aafbSBarry Smith Level: beginner 2014d382aafbSBarry Smith 2015d382aafbSBarry Smith Note: In MPI calls that require an MPI datatype that matches a PetscScalar or array of PetscScalars 2016d382aafbSBarry Smith pass this value 2017d382aafbSBarry Smith 2018d382aafbSBarry Smith .seealso: PetscReal, PassiveReal, PassiveScalar, PetscScalar, MPIU_INT 2019d382aafbSBarry Smith M*/ 2020d382aafbSBarry Smith 2021d382aafbSBarry Smith #if defined(PETSC_HAVE_MPIIO) 2022d382aafbSBarry Smith #if !defined(PETSC_WORDS_BIGENDIAN) 2023d382aafbSBarry Smith extern PetscErrorCode MPIU_File_write_all(MPI_File,void*,PetscMPIInt,MPI_Datatype,MPI_Status*); 2024d382aafbSBarry Smith extern PetscErrorCode MPIU_File_read_all(MPI_File,void*,PetscMPIInt,MPI_Datatype,MPI_Status*); 2025d382aafbSBarry Smith #else 2026d382aafbSBarry Smith #define MPIU_File_write_all(a,b,c,d,e) MPI_File_write_all(a,b,c,d,e) 2027d382aafbSBarry Smith #define MPIU_File_read_all(a,b,c,d,e) MPI_File_read_all(a,b,c,d,e) 2028d382aafbSBarry Smith #endif 2029d382aafbSBarry Smith #endif 2030d382aafbSBarry Smith 2031d382aafbSBarry Smith /* the following petsc_static_inline require petscerror.h */ 2032d382aafbSBarry Smith 2033d382aafbSBarry Smith /* Limit MPI to 32-bits */ 2034d382aafbSBarry Smith #define PETSC_MPI_INT_MAX 2147483647 2035d382aafbSBarry Smith #define PETSC_MPI_INT_MIN -2147483647 2036d382aafbSBarry Smith /* Limit BLAS to 32-bits */ 2037d382aafbSBarry Smith #define PETSC_BLAS_INT_MAX 2147483647 2038d382aafbSBarry Smith #define PETSC_BLAS_INT_MIN -2147483647 2039d382aafbSBarry Smith /* On 32 bit systems HDF5 is limited by size of integer, because hsize_t is defined as size_t */ 2040d382aafbSBarry Smith #define PETSC_HDF5_INT_MAX 2147483647 2041d382aafbSBarry Smith #define PETSC_HDF5_INT_MIN -2147483647 2042d382aafbSBarry Smith 2043d382aafbSBarry Smith #if defined(PETSC_USE_64BIT_INDICES) 2044d382aafbSBarry Smith #define PetscMPIIntCheck(a) if ((a) > PETSC_MPI_INT_MAX) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Message too long for MPI") 2045d382aafbSBarry Smith #define PetscBLASIntCheck(a) if ((a) > PETSC_BLAS_INT_MAX) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Array too long for BLAS/LAPACK") 2046d382aafbSBarry Smith #define PetscMPIIntCast(a) (a);PetscMPIIntCheck(a) 2047d382aafbSBarry Smith #define PetscBLASIntCast(a) (a);PetscBLASIntCheck(a) 2048d382aafbSBarry Smith 2049d382aafbSBarry Smith #if (PETSC_SIZEOF_SIZE_T == 4) 2050d382aafbSBarry Smith #define PetscHDF5IntCheck(a) if ((a) > PETSC_HDF5_INT_MAX) SETERRQ(PETSC_ERR_ARG_OUTOFRANGE,"Array too long for HDF5") 2051d382aafbSBarry Smith #define PetscHDF5IntCast(a) (a);PetscHDF5IntCheck(a) 2052d382aafbSBarry Smith #else 2053d382aafbSBarry Smith #define PetscHDF5IntCheck(a) 2054d382aafbSBarry Smith #define PetscHDF5IntCast(a) a 2055d382aafbSBarry Smith #endif 2056d382aafbSBarry Smith 2057d382aafbSBarry Smith #else 2058d382aafbSBarry Smith #define PetscMPIIntCheck(a) 2059d382aafbSBarry Smith #define PetscBLASIntCheck(a) 2060d382aafbSBarry Smith #define PetscHDF5IntCheck(a) 2061d382aafbSBarry Smith #define PetscMPIIntCast(a) a 2062d382aafbSBarry Smith #define PetscBLASIntCast(a) a 2063d382aafbSBarry Smith #define PetscHDF5IntCast(a) a 2064d382aafbSBarry Smith #endif 2065d382aafbSBarry Smith 2066d382aafbSBarry Smith 2067d382aafbSBarry Smith /* 2068d382aafbSBarry Smith The IBM include files define hz, here we hide it so that it may be used 2069d382aafbSBarry Smith as a regular user variable. 2070d382aafbSBarry Smith */ 2071d382aafbSBarry Smith #if defined(hz) 2072d382aafbSBarry Smith #undef hz 2073d382aafbSBarry Smith #endif 2074d382aafbSBarry Smith 2075d382aafbSBarry Smith /* For arrays that contain filenames or paths */ 2076d382aafbSBarry Smith 2077d382aafbSBarry Smith 2078d382aafbSBarry Smith #if defined(PETSC_HAVE_LIMITS_H) 2079d382aafbSBarry Smith #include <limits.h> 2080d382aafbSBarry Smith #endif 2081d382aafbSBarry Smith #if defined(PETSC_HAVE_SYS_PARAM_H) 2082d382aafbSBarry Smith #include <sys/param.h> 2083d382aafbSBarry Smith #endif 2084d382aafbSBarry Smith #if defined(PETSC_HAVE_SYS_TYPES_H) 2085d382aafbSBarry Smith #include <sys/types.h> 2086d382aafbSBarry Smith #endif 2087d382aafbSBarry Smith #if defined(MAXPATHLEN) 2088d382aafbSBarry Smith # define PETSC_MAX_PATH_LEN MAXPATHLEN 2089d382aafbSBarry Smith #elif defined(MAX_PATH) 2090d382aafbSBarry Smith # define PETSC_MAX_PATH_LEN MAX_PATH 2091d382aafbSBarry Smith #elif defined(_MAX_PATH) 2092d382aafbSBarry Smith # define PETSC_MAX_PATH_LEN _MAX_PATH 2093d382aafbSBarry Smith #else 2094d382aafbSBarry Smith # define PETSC_MAX_PATH_LEN 4096 2095d382aafbSBarry Smith #endif 2096d382aafbSBarry Smith 2097d382aafbSBarry Smith /* Special support for C++ */ 2098d382aafbSBarry Smith #include "petscsys.hh" 20996c7e564aSBarry Smith 2100d382aafbSBarry Smith 2101d382aafbSBarry Smith /*MC 2102d382aafbSBarry Smith 2103d382aafbSBarry Smith UsingFortran - Fortran can be used with PETSc in four distinct approaches 2104d382aafbSBarry Smith 2105d382aafbSBarry Smith $ 1) classic Fortran 77 style 2106d382aafbSBarry Smith $#include "petscXXX.h" to work with material from the XXX component of PETSc 2107d382aafbSBarry Smith $ XXX variablename 2108d382aafbSBarry Smith $ You cannot use this approach if you wish to use the Fortran 90 specific PETSc routines 2109d382aafbSBarry Smith $ which end in F90; such as VecGetArrayF90() 2110d382aafbSBarry Smith $ 2111d382aafbSBarry Smith $ 2) classic Fortran 90 style 2112d382aafbSBarry Smith $#include "petscXXX.h" 2113d382aafbSBarry Smith $#include "petscXXX.h90" to work with material from the XXX component of PETSc 2114d382aafbSBarry Smith $ XXX variablename 2115d382aafbSBarry Smith $ 2116d382aafbSBarry Smith $ 3) Using Fortran modules 2117d382aafbSBarry Smith $#include "petscXXXdef.h" 2118d382aafbSBarry Smith $ use petscXXXX 2119d382aafbSBarry Smith $ XXX variablename 2120d382aafbSBarry Smith $ 2121d382aafbSBarry Smith $ 4) Use Fortran modules and Fortran data types for PETSc types 2122d382aafbSBarry Smith $#include "petscXXXdef.h" 2123d382aafbSBarry Smith $ use petscXXXX 2124d382aafbSBarry Smith $ type(XXX) variablename 2125d382aafbSBarry Smith $ To use this approach you must config/configure.py PETSc with the additional 2126d382aafbSBarry Smith $ option --with-fortran-datatypes You cannot use the type(XXX) declaration approach without using Fortran modules 2127d382aafbSBarry Smith 2128d382aafbSBarry Smith Finally if you absolutely do not want to use any #include you can use either 2129d382aafbSBarry Smith 2130d382aafbSBarry Smith $ 3a) skip the #include BUT you cannot use any PETSc data type names like Vec, Mat, PetscInt, PetscErrorCode etc 2131d382aafbSBarry Smith $ and you must declare the variables as integer, for example 2132d382aafbSBarry Smith $ integer variablename 2133d382aafbSBarry Smith $ 2134d382aafbSBarry Smith $ 4a) skip the #include, you use the object types like type(Vec) type(Mat) but cannot use the data type 2135d382aafbSBarry Smith $ names like PetscErrorCode, PetscInt etc. again for those you must use integer 2136d382aafbSBarry Smith 2137d382aafbSBarry Smith We recommend either 2 or 3. Approaches 2 and 3 provide type checking for most PETSc function calls; 4 has type checking 2138d382aafbSBarry Smith for only a few PETSc functions. 2139d382aafbSBarry Smith 2140d382aafbSBarry Smith Fortran type checking with interfaces is strick, this means you cannot pass a scalar value when an array value 2141d382aafbSBarry Smith is expected (even though it is legal Fortran). For example when setting a single value in a matrix with MatSetValues() 2142d382aafbSBarry Smith you cannot have something like 2143d382aafbSBarry Smith $ PetscInt row,col 2144d382aafbSBarry Smith $ PetscScalar val 2145d382aafbSBarry Smith $ ... 2146d382aafbSBarry Smith $ call MatSetValues(mat,1,row,1,col,val,INSERT_VALUES,ierr) 2147d382aafbSBarry Smith You must instead have 2148d382aafbSBarry Smith $ PetscInt row(1),col(1) 2149d382aafbSBarry Smith $ PetscScalar val(1) 2150d382aafbSBarry Smith $ ... 2151d382aafbSBarry Smith $ call MatSetValues(mat,1,row,1,col,val,INSERT_VALUES,ierr) 2152d382aafbSBarry Smith 2153d382aafbSBarry Smith 2154d382aafbSBarry Smith See the example src/vec/vec/examples/tutorials/ex20f90.F90 for an example that can use all four approaches 2155d382aafbSBarry Smith 2156d382aafbSBarry Smith Developer Notes: The finclude/petscXXXdef.h contain all the #defines (would be typedefs in C code) these 2157d382aafbSBarry Smith automatically include their predecessors; for example finclude/petscvecdef.h includes finclude/petscisdef.h 2158d382aafbSBarry Smith 2159d382aafbSBarry Smith The finclude/petscXXXX.h contain all the parameter statements for that package. These automatically include 2160d382aafbSBarry Smith their finclude/petscXXXdef.h file but DO NOT automatically include their predecessors; for example 2161d382aafbSBarry Smith finclude/petscvec.h does NOT automatically include finclude/petscis.h 2162d382aafbSBarry Smith 2163d382aafbSBarry Smith The finclude/ftn-custom/petscXXXdef.h90 are not intended to be used directly in code, they define the 2164d382aafbSBarry Smith Fortran data type type(XXX) (for example type(Vec)) when PETSc is config/configure.py with the --with-fortran-datatypes option. 2165d382aafbSBarry Smith 2166d382aafbSBarry Smith The finclude/ftn-custom/petscXXX.h90 (not included directly by code) contain interface definitions for 2167d382aafbSBarry Smith the PETSc Fortran stubs that have different bindings then their C version (for example VecGetArrayF90). 2168d382aafbSBarry Smith 2169d382aafbSBarry Smith The finclude/ftn-auto/petscXXX.h90 (not included directly by code) contain interface definitions generated 2170d382aafbSBarry Smith automatically by "make allfortranstubs". 2171d382aafbSBarry Smith 2172d382aafbSBarry Smith The finclude/petscXXX.h90 includes the custom finclude/ftn-custom/petscXXX.h90 and if config/configure.py 2173d382aafbSBarry Smith was run with --with-fortran-interfaces it also includes the finclude/ftn-auto/petscXXX.h90 These DO NOT automatically 2174d382aafbSBarry Smith include their predecessors 2175d382aafbSBarry Smith 2176d382aafbSBarry Smith Level: beginner 2177d382aafbSBarry Smith 2178d382aafbSBarry Smith M*/ 2179d382aafbSBarry Smith 2180d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetArchType(char[],size_t); 2181d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetHostName(char[],size_t); 2182d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetUserName(char[],size_t); 2183d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetProgramName(char[],size_t); 2184d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetProgramName(const char[]); 2185d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetDate(char[],size_t); 2186d382aafbSBarry Smith 2187d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortInt(PetscInt,PetscInt[]); 2188d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortIntWithPermutation(PetscInt,const PetscInt[],PetscInt[]); 2189d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortStrWithPermutation(PetscInt,const char*[],PetscInt[]); 2190d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortIntWithArray(PetscInt,PetscInt[],PetscInt[]); 2191d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortMPIIntWithArray(PetscMPIInt,PetscMPIInt[],PetscMPIInt[]); 2192d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortIntWithScalarArray(PetscInt,PetscInt[],PetscScalar[]); 2193d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortReal(PetscInt,PetscReal[]); 2194d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortRealWithPermutation(PetscInt,const PetscReal[],PetscInt[]); 2195d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortSplit(PetscInt,PetscInt,PetscScalar[],PetscInt[]); 2196d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSortSplitReal(PetscInt,PetscInt,PetscReal[],PetscInt[]); 2197d382aafbSBarry Smith 2198d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDisplay(void); 2199d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetDisplay(char[],size_t); 2200d382aafbSBarry Smith 2201d382aafbSBarry Smith /*E 2202d382aafbSBarry Smith PetscRandomType - String with the name of a PETSc randomizer 2203d382aafbSBarry Smith with an optional dynamic library name, for example 2204d382aafbSBarry Smith http://www.mcs.anl.gov/petsc/lib.a:myrandcreate() 2205d382aafbSBarry Smith 2206d382aafbSBarry Smith Level: beginner 2207d382aafbSBarry Smith 2208d382aafbSBarry Smith Notes: to use the SPRNG you must have config/configure.py PETSc 2209d382aafbSBarry Smith with the option --download-sprng 2210d382aafbSBarry Smith 2211d382aafbSBarry Smith .seealso: PetscRandomSetType(), PetscRandom 2212d382aafbSBarry Smith E*/ 2213d382aafbSBarry Smith #define PetscRandomType char* 2214d382aafbSBarry Smith #define PETSCRAND "rand" 2215d382aafbSBarry Smith #define PETSCRAND48 "rand48" 2216d382aafbSBarry Smith #define PETSCSPRNG "sprng" 2217d382aafbSBarry Smith 2218d382aafbSBarry Smith /* Logging support */ 2219d382aafbSBarry Smith extern PETSC_DLLEXPORT PetscCookie PETSC_RANDOM_COOKIE; 2220d382aafbSBarry Smith 2221d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomInitializePackage(const char[]); 2222d382aafbSBarry Smith 2223d382aafbSBarry Smith /*S 2224d382aafbSBarry Smith PetscRandom - Abstract PETSc object that manages generating random numbers 2225d382aafbSBarry Smith 2226d382aafbSBarry Smith Level: intermediate 2227d382aafbSBarry Smith 2228d382aafbSBarry Smith Concepts: random numbers 2229d382aafbSBarry Smith 2230d382aafbSBarry Smith .seealso: PetscRandomCreate(), PetscRandomGetValue(), PetscRandomType 2231d382aafbSBarry Smith S*/ 2232d382aafbSBarry Smith typedef struct _p_PetscRandom* PetscRandom; 2233d382aafbSBarry Smith 2234d382aafbSBarry Smith /* Dynamic creation and loading functions */ 2235d382aafbSBarry Smith extern PetscFList PetscRandomList; 2236d382aafbSBarry Smith extern PetscTruth PetscRandomRegisterAllCalled; 2237d382aafbSBarry Smith 2238d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomRegisterAll(const char []); 2239d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomRegister(const char[],const char[],const char[],PetscErrorCode (*)(PetscRandom)); 2240d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomRegisterDestroy(void); 2241d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSetType(PetscRandom, const PetscRandomType); 2242d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSetFromOptions(PetscRandom); 2243d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetType(PetscRandom, const PetscRandomType*); 2244d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomViewFromOptions(PetscRandom,char*); 2245d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomView(PetscRandom,PetscViewer); 2246d382aafbSBarry Smith 2247d382aafbSBarry Smith /*MC 2248d382aafbSBarry Smith PetscRandomRegisterDynamic - Adds a new PetscRandom component implementation 2249d382aafbSBarry Smith 2250d382aafbSBarry Smith Synopsis: 22511890ba74SBarry Smith PetscErrorCode PetscRandomRegisterDynamic(const char *name, const char *path, const char *func_name, PetscErrorCode (*create_func)(PetscRandom)) 2252d382aafbSBarry Smith 2253d382aafbSBarry Smith Not Collective 2254d382aafbSBarry Smith 2255d382aafbSBarry Smith Input Parameters: 2256d382aafbSBarry Smith + name - The name of a new user-defined creation routine 2257d382aafbSBarry Smith . path - The path (either absolute or relative) of the library containing this routine 2258d382aafbSBarry Smith . func_name - The name of routine to create method context 2259d382aafbSBarry Smith - create_func - The creation routine itself 2260d382aafbSBarry Smith 2261d382aafbSBarry Smith Notes: 2262d382aafbSBarry Smith PetscRandomRegisterDynamic() may be called multiple times to add several user-defined randome number generators 2263d382aafbSBarry Smith 2264d382aafbSBarry Smith If dynamic libraries are used, then the fourth input argument (routine_create) is ignored. 2265d382aafbSBarry Smith 2266d382aafbSBarry Smith Sample usage: 2267d382aafbSBarry Smith .vb 2268d382aafbSBarry Smith PetscRandomRegisterDynamic("my_rand","/home/username/my_lib/lib/libO/solaris/libmy.a", "MyPetscRandomtorCreate", MyPetscRandomtorCreate); 2269d382aafbSBarry Smith .ve 2270d382aafbSBarry Smith 2271d382aafbSBarry Smith Then, your random type can be chosen with the procedural interface via 2272d382aafbSBarry Smith .vb 2273d382aafbSBarry Smith PetscRandomCreate(MPI_Comm, PetscRandom *); 2274d382aafbSBarry Smith PetscRandomSetType(PetscRandom,"my_random_name"); 2275d382aafbSBarry Smith .ve 2276d382aafbSBarry Smith or at runtime via the option 2277d382aafbSBarry Smith .vb 2278d382aafbSBarry Smith -random_type my_random_name 2279d382aafbSBarry Smith .ve 2280d382aafbSBarry Smith 2281d382aafbSBarry Smith Notes: $PETSC_ARCH occuring in pathname will be replaced with appropriate values. 2282d382aafbSBarry Smith 2283d382aafbSBarry Smith For an example of the code needed to interface your own random number generator see 2284d382aafbSBarry Smith src/sys/random/impls/rand/rand.c 2285d382aafbSBarry Smith 2286d382aafbSBarry Smith Level: advanced 2287d382aafbSBarry Smith 2288d382aafbSBarry Smith .keywords: PetscRandom, register 2289d382aafbSBarry Smith .seealso: PetscRandomRegisterAll(), PetscRandomRegisterDestroy(), PetscRandomRegister() 2290d382aafbSBarry Smith M*/ 2291d382aafbSBarry Smith #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 2292d382aafbSBarry Smith #define PetscRandomRegisterDynamic(a,b,c,d) PetscRandomRegister(a,b,c,0) 2293d382aafbSBarry Smith #else 2294d382aafbSBarry Smith #define PetscRandomRegisterDynamic(a,b,c,d) PetscRandomRegister(a,b,c,d) 2295d382aafbSBarry Smith #endif 2296d382aafbSBarry Smith 2297d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomCreate(MPI_Comm,PetscRandom*); 2298d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetValue(PetscRandom,PetscScalar*); 2299d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetValueReal(PetscRandom,PetscReal*); 2300d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetInterval(PetscRandom,PetscScalar*,PetscScalar*); 2301d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSetInterval(PetscRandom,PetscScalar,PetscScalar); 2302d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSetSeed(PetscRandom,unsigned long); 2303d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomGetSeed(PetscRandom,unsigned long *); 2304d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomSeed(PetscRandom); 2305d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscRandomDestroy(PetscRandom); 2306d382aafbSBarry Smith 2307d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetFullPath(const char[],char[],size_t); 2308d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetRelativePath(const char[],char[],size_t); 2309d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetWorkingDirectory(char[],size_t); 2310d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetRealPath(const char[],char[]); 2311d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetHomeDirectory(char[],size_t); 2312d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTestFile(const char[],char,PetscTruth*); 2313d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscTestDirectory(const char[],char,PetscTruth*); 2314d382aafbSBarry Smith 2315d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinaryRead(int,void*,PetscInt,PetscDataType); 2316d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinarySynchronizedRead(MPI_Comm,int,void*,PetscInt,PetscDataType); 2317d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinarySynchronizedWrite(MPI_Comm,int,void*,PetscInt,PetscDataType,PetscTruth); 2318d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinaryWrite(int,void*,PetscInt,PetscDataType,PetscTruth); 2319d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinaryOpen(const char[],PetscFileMode,int *); 2320d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinaryClose(int); 2321d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSharedTmp(MPI_Comm,PetscTruth *); 2322d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSharedWorkingDirectory(MPI_Comm,PetscTruth *); 2323d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGetTmp(MPI_Comm,char[],size_t); 2324d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscFileRetrieve(MPI_Comm,const char[],char[],size_t,PetscTruth*); 2325d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscLs(MPI_Comm,const char[],char[],size_t,PetscTruth*); 2326d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscOpenSocket(char*,int,int*); 2327d382aafbSBarry Smith 2328d382aafbSBarry Smith /* 2329d382aafbSBarry Smith In binary files variables are stored using the following lengths, 2330d382aafbSBarry Smith regardless of how they are stored in memory on any one particular 2331d382aafbSBarry Smith machine. Use these rather then sizeof() in computing sizes for 2332d382aafbSBarry Smith PetscBinarySeek(). 2333d382aafbSBarry Smith */ 2334d382aafbSBarry Smith #define PETSC_BINARY_INT_SIZE (32/8) 2335d382aafbSBarry Smith #define PETSC_BINARY_FLOAT_SIZE (32/8) 2336d382aafbSBarry Smith #define PETSC_BINARY_CHAR_SIZE (8/8) 2337d382aafbSBarry Smith #define PETSC_BINARY_SHORT_SIZE (16/8) 2338d382aafbSBarry Smith #define PETSC_BINARY_DOUBLE_SIZE (64/8) 2339d382aafbSBarry Smith #define PETSC_BINARY_SCALAR_SIZE sizeof(PetscScalar) 2340d382aafbSBarry Smith 2341d382aafbSBarry Smith /*E 2342d382aafbSBarry Smith PetscBinarySeekType - argument to PetscBinarySeek() 2343d382aafbSBarry Smith 2344d382aafbSBarry Smith Level: advanced 2345d382aafbSBarry Smith 2346d382aafbSBarry Smith .seealso: PetscBinarySeek(), PetscBinarySynchronizedSeek() 2347d382aafbSBarry Smith E*/ 2348d382aafbSBarry Smith typedef enum {PETSC_BINARY_SEEK_SET = 0,PETSC_BINARY_SEEK_CUR = 1,PETSC_BINARY_SEEK_END = 2} PetscBinarySeekType; 2349d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinarySeek(int,off_t,PetscBinarySeekType,off_t*); 2350d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscBinarySynchronizedSeek(MPI_Comm,int,off_t,PetscBinarySeekType,off_t*); 2351d382aafbSBarry Smith 2352d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDebugTerminal(const char[]); 2353d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDebugger(const char[],PetscTruth); 2354d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDefaultDebugger(void); 2355d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSetDebuggerFromString(char*); 2356d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscAttachDebugger(void); 2357d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscStopForDebugger(void); 2358d382aafbSBarry Smith 2359d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGatherNumberOfMessages(MPI_Comm,const PetscMPIInt[],const PetscMPIInt[],PetscMPIInt*); 2360d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGatherMessageLengths(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],PetscMPIInt**,PetscMPIInt**); 2361d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscGatherMessageLengths2(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscMPIInt**,PetscMPIInt**,PetscMPIInt**); 2362d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPostIrecvInt(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscInt***,MPI_Request**); 2363d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscPostIrecvScalar(MPI_Comm,PetscMPIInt,PetscMPIInt,const PetscMPIInt[],const PetscMPIInt[],PetscScalar***,MPI_Request**); 2364d382aafbSBarry Smith 2365d382aafbSBarry Smith EXTERN PetscErrorCode PETSC_DLLEXPORT PetscSSEIsEnabled(MPI_Comm,PetscTruth *,PetscTruth *); 2366d382aafbSBarry Smith 2367d382aafbSBarry Smith /*E 2368d382aafbSBarry Smith InsertMode - Whether entries are inserted or added into vectors or matrices 2369d382aafbSBarry Smith 2370d382aafbSBarry Smith Level: beginner 2371d382aafbSBarry Smith 2372d382aafbSBarry Smith .seealso: VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(), 2373d382aafbSBarry Smith VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), 2374d382aafbSBarry Smith MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd() 2375d382aafbSBarry Smith E*/ 2376d382aafbSBarry Smith typedef enum {NOT_SET_VALUES, INSERT_VALUES, ADD_VALUES, MAX_VALUES} InsertMode; 2377d382aafbSBarry Smith 2378d382aafbSBarry Smith /*MC 2379d382aafbSBarry Smith INSERT_VALUES - Put a value into a vector or matrix, overwrites any previous value 2380d382aafbSBarry Smith 2381d382aafbSBarry Smith Level: beginner 2382d382aafbSBarry Smith 2383d382aafbSBarry Smith .seealso: InsertMode, VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(), 2384*eca87e8dSBarry Smith VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), ADD_VALUES, 2385*eca87e8dSBarry Smith MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd(), MAX_VALUES 2386d382aafbSBarry Smith 2387d382aafbSBarry Smith M*/ 2388d382aafbSBarry Smith 2389d382aafbSBarry Smith /*MC 2390d382aafbSBarry Smith ADD_VALUES - Adds a value into a vector or matrix, if there previously was no value, just puts the 2391d382aafbSBarry Smith value into that location 2392d382aafbSBarry Smith 2393d382aafbSBarry Smith Level: beginner 2394d382aafbSBarry Smith 2395d382aafbSBarry Smith .seealso: InsertMode, VecSetValues(), MatSetValues(), VecSetValue(), VecSetValuesBlocked(), 2396*eca87e8dSBarry Smith VecSetValuesLocal(), VecSetValuesBlockedLocal(), MatSetValuesBlocked(), INSERT_VALUES, 2397*eca87e8dSBarry Smith MatSetValuesBlockedLocal(), MatSetValuesLocal(), VecScatterBegin(), VecScatterEnd(), MAX_VALUES 2398d382aafbSBarry Smith 2399d382aafbSBarry Smith M*/ 2400d382aafbSBarry Smith 2401d382aafbSBarry Smith /*MC 2402d382aafbSBarry Smith MAX_VALUES - Puts the maximum of the scattered/gathered value and the current value into each location 2403d382aafbSBarry Smith 2404d382aafbSBarry Smith Level: beginner 2405d382aafbSBarry Smith 2406d382aafbSBarry Smith .seealso: InsertMode, VecScatterBegin(), VecScatterEnd(), ADD_VALUES, INSERT_VALUES 2407d382aafbSBarry Smith 2408d382aafbSBarry Smith M*/ 2409d382aafbSBarry Smith 2410d382aafbSBarry Smith /*E 2411d382aafbSBarry Smith ScatterMode - Determines the direction of a scatter 2412d382aafbSBarry Smith 2413d382aafbSBarry Smith Level: beginner 2414d382aafbSBarry Smith 2415d382aafbSBarry Smith .seealso: VecScatter, VecScatterBegin(), VecScatterEnd() 2416d382aafbSBarry Smith E*/ 2417d382aafbSBarry Smith typedef enum {SCATTER_FORWARD=0, SCATTER_REVERSE=1, SCATTER_FORWARD_LOCAL=2, SCATTER_REVERSE_LOCAL=3, SCATTER_LOCAL=2} ScatterMode; 2418d382aafbSBarry Smith 2419d382aafbSBarry Smith /*MC 2420d382aafbSBarry Smith SCATTER_FORWARD - Scatters the values as dictated by the VecScatterCreate() call 2421d382aafbSBarry Smith 2422d382aafbSBarry Smith Level: beginner 2423d382aafbSBarry Smith 2424d382aafbSBarry Smith .seealso: VecScatter, ScatterMode, VecScatterCreate(), VecScatterBegin(), VecScatterEnd(), SCATTER_REVERSE, SCATTER_FORWARD_LOCAL, 2425d382aafbSBarry Smith SCATTER_REVERSE_LOCAL 2426d382aafbSBarry Smith 2427d382aafbSBarry Smith M*/ 2428d382aafbSBarry Smith 2429d382aafbSBarry Smith /*MC 2430d382aafbSBarry Smith SCATTER_REVERSE - Moves the values in the opposite direction then the directions indicated in 2431d382aafbSBarry Smith in the VecScatterCreate() 2432d382aafbSBarry Smith 2433d382aafbSBarry Smith Level: beginner 2434d382aafbSBarry Smith 2435d382aafbSBarry Smith .seealso: VecScatter, ScatterMode, VecScatterCreate(), VecScatterBegin(), VecScatterEnd(), SCATTER_FORWARD, SCATTER_FORWARD_LOCAL, 2436d382aafbSBarry Smith SCATTER_REVERSE_LOCAL 2437d382aafbSBarry Smith 2438d382aafbSBarry Smith M*/ 2439d382aafbSBarry Smith 2440d382aafbSBarry Smith /*MC 2441d382aafbSBarry Smith SCATTER_FORWARD_LOCAL - Scatters the values as dictated by the VecScatterCreate() call except NO parallel communication 2442d382aafbSBarry Smith is done. Any variables that have be moved between processes are ignored 2443d382aafbSBarry Smith 2444d382aafbSBarry Smith Level: developer 2445d382aafbSBarry Smith 2446d382aafbSBarry Smith .seealso: VecScatter, ScatterMode, VecScatterCreate(), VecScatterBegin(), VecScatterEnd(), SCATTER_REVERSE, SCATTER_FORWARD, 2447d382aafbSBarry Smith SCATTER_REVERSE_LOCAL 2448d382aafbSBarry Smith 2449d382aafbSBarry Smith M*/ 2450d382aafbSBarry Smith 2451d382aafbSBarry Smith /*MC 2452d382aafbSBarry Smith SCATTER_REVERSE_LOCAL - Moves the values in the opposite direction then the directions indicated in 2453d382aafbSBarry Smith in the VecScatterCreate() except NO parallel communication 2454d382aafbSBarry Smith is done. Any variables that have be moved between processes are ignored 2455d382aafbSBarry Smith 2456d382aafbSBarry Smith Level: developer 2457d382aafbSBarry Smith 2458d382aafbSBarry Smith .seealso: VecScatter, ScatterMode, VecScatterCreate(), VecScatterBegin(), VecScatterEnd(), SCATTER_FORWARD, SCATTER_FORWARD_LOCAL, 2459d382aafbSBarry Smith SCATTER_REVERSE 2460d382aafbSBarry Smith 2461d382aafbSBarry Smith M*/ 2462d382aafbSBarry Smith 2463d382aafbSBarry Smith /*S 2464d382aafbSBarry Smith PetscSubcomm - Context of MPI subcommunicators, used by PCREDUNDANT 2465d382aafbSBarry Smith 2466d382aafbSBarry Smith Level: advanced 2467d382aafbSBarry Smith 2468d382aafbSBarry Smith Concepts: communicator, create 2469d382aafbSBarry Smith S*/ 2470d382aafbSBarry Smith typedef struct _n_PetscSubcomm* PetscSubcomm; 2471d382aafbSBarry Smith 2472d382aafbSBarry Smith struct _n_PetscSubcomm { 2473d382aafbSBarry Smith MPI_Comm parent; /* parent communicator */ 2474d382aafbSBarry Smith MPI_Comm dupparent; /* duplicate parent communicator, under which the processors of this subcomm have contiguous rank */ 2475d382aafbSBarry Smith MPI_Comm comm; /* this communicator */ 2476d382aafbSBarry Smith PetscInt n; /* num of subcommunicators under the parent communicator */ 2477d382aafbSBarry Smith PetscInt color; /* color of processors belong to this communicator */ 2478d382aafbSBarry Smith }; 2479d382aafbSBarry Smith 2480d382aafbSBarry Smith EXTERN PetscErrorCode PETSCMAT_DLLEXPORT PetscSubcommCreate(MPI_Comm,PetscInt,PetscSubcomm*); 2481d382aafbSBarry Smith EXTERN PetscErrorCode PETSCMAT_DLLEXPORT PetscSubcommDestroy(PetscSubcomm); 2482d382aafbSBarry Smith 2483d382aafbSBarry Smith PETSC_EXTERN_CXX_END 24846c7e564aSBarry Smith 2485d382aafbSBarry Smith #endif 2486