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