1 /* $Id: petsc.h,v 1.231 1998/10/28 22:54:22 curfman Exp bsmith $ */ 2 /* 3 This is the main PETSc include file (for C and C++). It is included by all 4 other PETSc include files, so it almost never has to be specifically included. 5 */ 6 #if !defined(__PETSC_H) 7 #define __PETSC_H 8 9 /* ========================================================================== */ 10 /* 11 Current PETSc version number and release date, also listed in 12 docs/changes.html 13 docs/tex/manual/manual.tex and 14 docs/tex/manual/manual_tex.tex. 15 */ 16 #define PETSC_VERSION_NUMBER "PETSc Version 2.0.24, Released ???" 17 18 #define PETSC_VERSION_MAJOR 2 19 #define PETSC_VERSION_MINOR 0 20 #define PETSC_VERSION_SUBMINOR 24 21 #define PETSC_VERSION_DATE "Yet to be determined, 1998" 22 #define PETSC_AUTHOR_INFO "The PETSc Team:\ 23 Satish Balay, Bill Gropp, Lois Curfman McInnes, Barry Smith\n\ 24 Bug reports, questions: petsc-maint@mcs.anl.gov\n\ 25 Web page: http://www.mcs.anl.gov/petsc/\n" 26 27 /* ========================================================================== */ 28 /* 29 The PETSc configuration file. Contains various definitions that 30 handle portability issues and the presence of machine features. 31 32 petscconf.h is contained in bmake/${PETSC_ARCH}/petscconf.h it is 33 found automatically by the compiler due to the -I${PETSC_DIR}/bmake/${PETSC_ARCH} 34 in the bmake/common definition of PETSC_INCLUDE 35 */ 36 #include "petscconf.h" 37 38 /* ========================================================================== */ 39 40 #include <stdio.h> 41 /* 42 Defines the interface to MPI allowing the use of all MPI functions. 43 */ 44 #include "mpi.h" 45 46 /* 47 Defines some elementary mathematics functions and constants. 48 */ 49 #include "petscmath.h" 50 51 /* 52 Variable type where we stash PETSc object pointers in Fortran. 53 Assumes that sizeof(long) == sizeof(void *) which is true on 54 all machines that we know. 55 */ 56 #define PetscFortranAddr long 57 58 extern MPI_Comm PETSC_COMM_WORLD; 59 extern MPI_Comm PETSC_COMM_SELF; 60 extern int PetscInitializedCalled; 61 extern int PetscSetCommWorld(MPI_Comm); 62 63 /* 64 Defines the malloc employed by PETSc. Users may use these routines as well. 65 */ 66 #define PetscMalloc(a) (*PetscTrMalloc)(a,__LINE__,__FUNC__,__FILE__,__SDIR__) 67 #define PetscNew(A) (A*) PetscMalloc(sizeof(A)) 68 #define PetscFree(a) (*PetscTrFree)(a,__LINE__,__FUNC__,__FILE__,__SDIR__) 69 extern void *(*PetscTrMalloc)(unsigned int,int,char*,char*,char*); 70 extern int (*PetscTrFree)(void *,int,char*,char*,char*); 71 extern int PetscSetMalloc(void *(*)(unsigned int,int,char*,char*,char*), 72 int (*)(void *,int,char*,char*,char*)); 73 extern int PetscClearMalloc(void); 74 75 /* 76 Routines for tracing memory corruption/bleeding with default PETSc 77 memory allocation 78 */ 79 extern int PetscTrDump(FILE *); 80 extern int PetscTrSpace(PLogDouble *, PLogDouble *,PLogDouble *); 81 extern int PetscTrValid(int,const char[],const char[],const char[]); 82 extern int PetscTrDebugLevel(int); 83 extern int PetscTrLog(void); 84 extern int PetscTrLogDump(FILE *); 85 extern int PetscGetResidentSetSize(PLogDouble *); 86 87 /* 88 Constants and functions used for handling different basic data types. 89 These are used, for example, in binary IO routines 90 */ 91 typedef enum {PETSC_INT = 0, PETSC_DOUBLE = 1, PETSC_SHORT = 2, PETSC_FLOAT = 3, 92 PETSC_COMPLEX = 4, PETSC_CHAR = 5, PETSC_LOGICAL = 6} PetscDataType; 93 #if defined(USE_PETSC_COMPLEX) 94 #define PETSC_SCALAR PETSC_COMPLEX 95 #else 96 #define PETSC_SCALAR PETSC_DOUBLE 97 #endif 98 typedef enum {PETSC_INT_SIZE = sizeof(int), PETSC_DOUBLE_SIZE = sizeof(double), 99 PETSC_SCALAR_SIZE = sizeof(Scalar), PETSC_COMPLEX_SIZE = sizeof(double), 100 PETSC_CHAR_SIZE = sizeof(char), PETSC_LOGICAL_SIZE = 1} PetscDataTypeSize; 101 extern int PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*); 102 extern int PetscDataTypeGetSize(PetscDataType,int*); 103 extern int PetscDataTypeGetName(PetscDataType,char*[]); 104 105 /* 106 Basic memory and string operations. These are usually simple wrappers 107 around the basic Unix system calls, but a few of them have additional 108 functionality and/or error checking. 109 */ 110 extern int PetscMemcpy(void *,const void *,int); 111 extern int PetscBitMemcpy(void*,int,const void*,int,int,PetscDataType); 112 extern int PetscMemmove(void *,void *,int); 113 extern int PetscMemzero(void *,int); 114 extern int PetscMemcmp(const void*,const void*, int); 115 extern int PetscStrlen(const char[]); 116 extern int PetscStrcmp(const char[],const char[]); 117 extern int PetscStrcasecmp(const char[],const char[]); 118 extern int PetscStrncmp(const char[],const char[],int ); 119 extern int PetscStrcpy(char[],const char[]); 120 extern int PetscStrcat(char[],const char[]); 121 extern int PetscStrncat(char[],const char[],int); 122 extern int PetscStrncpy(char[],const char[],int); 123 extern char* PetscStrchr(const char[],char); 124 extern char* PetscStrrchr(const char[],char); 125 extern char* PetscStrstr(const char[],const char[]); 126 extern char* PetscStrtok(const char[],const char[]); 127 128 /* 129 Basic PETSc constants 130 */ 131 typedef enum { PETSC_FALSE, PETSC_TRUE } PetscTruth; 132 #define PETSC_NULL 0 133 #define PETSC_DECIDE -1 134 #define PETSC_DETERMINE PETSC_DECIDE 135 #define PETSC_DEFAULT -2 136 137 /* 138 Each PETSc object class has it's own cookie (internal integer in the 139 data structure used for error checking). These are all defined by an offset 140 from the lowest one, PETSC_COOKIE. If you increase these you must 141 increase the field sizes in petsc/src/plog/src/plog.c 142 */ 143 #define PETSC_COOKIE 1211211 144 #define LARGEST_PETSC_COOKIE_PREDEFINED PETSC_COOKIE + 30 145 #define LARGEST_PETSC_COOKIE_ALLOWED PETSC_COOKIE + 50 146 extern int LARGEST_PETSC_COOKIE; 147 148 #include "viewer.h" 149 #include "options.h" 150 151 /* 152 Defines basic graphics available from PETSc. 153 */ 154 #include "draw.h" 155 156 extern int PetscGetTime(PLogDouble*); 157 extern int PetscGetCPUTime(PLogDouble*); 158 extern int PetscSleep(int); 159 160 /* 161 Initialization of PETSc or its micro-kernel ALICE 162 */ 163 extern int AliceInitialize(int*,char***,const char[],const char[]); 164 extern int AliceInitializeNoArguments(void); 165 extern int AliceFinalize(void); 166 extern void AliceInitializeFortran(void); 167 168 extern int PetscInitialize(int*,char***,char[],const char[]); 169 extern int PetscInitializeNoArguments(void); 170 extern int PetscFinalize(void); 171 extern void PetscInitializeFortran(void); 172 173 /* 174 Functions that can act on any PETSc object. 175 */ 176 typedef struct _p_PetscObject* PetscObject; 177 extern int PetscObjectDestroy(PetscObject); 178 extern int PetscObjectExists(PetscObject,int*); 179 extern int PetscObjectGetComm(PetscObject,MPI_Comm *comm); 180 extern int PetscObjectGetCookie(PetscObject,int *cookie); 181 extern int PetscObjectGetType(PetscObject,int *type); 182 extern int PetscObjectSetName(PetscObject,const char[]); 183 extern int PetscObjectGetName(PetscObject,char*[]); 184 extern int PetscObjectReference(PetscObject); 185 extern int PetscObjectGetReference(PetscObject,int*); 186 extern int PetscObjectDereference(PetscObject); 187 extern int PetscObjectGetNewTag(PetscObject,int *); 188 extern int PetscObjectRestoreNewTag(PetscObject,int *); 189 extern int PetscObjectView(PetscObject,Viewer); 190 extern int PetscObjectCompose(PetscObject,const char[],PetscObject); 191 extern int PetscObjectQuery(PetscObject,const char[],PetscObject *); 192 extern int PetscObjectComposeFunction_Private(PetscObject,const char[],const char[],void *); 193 #if defined(USE_DYNAMIC_LIBRARIES) 194 #define PetscObjectComposeFunction(a,b,c,d) PetscObjectComposeFunction_Private(a,b,c,0) 195 #else 196 #define PetscObjectComposeFunction(a,b,c,d) PetscObjectComposeFunction_Private(a,b,c,d) 197 #endif 198 extern int PetscObjectQueryFunction(PetscObject,const char[],void **); 199 extern int PetscObjectSetOptionsPrefix(PetscObject,const char[]); 200 extern int PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 201 extern int PetscObjectGetOptionsPrefix(PetscObject,char*[]); 202 extern int PetscObjectPublish(PetscObject); 203 204 /* 205 Defines PETSc error handling. 206 */ 207 #include "petscerror.h" 208 209 /* 210 Mechanism for managing lists of objects attached (composed) with 211 a PETSc object. 212 */ 213 typedef struct _OList *OList; 214 extern int OListDestroy(OList *); 215 extern int OListFind(OList,const char[],PetscObject*); 216 extern int OListAdd(OList *,const char[],PetscObject); 217 extern int OListDuplicate(OList,OList *); 218 219 /* 220 Dynamic library lists. Lists of names of routines in dynamic 221 link libraries that will be loaded as needed. 222 */ 223 typedef struct _FList *FList; 224 extern int FListAdd_Private(FList*,const char[],const char[],int (*)(void *)); 225 extern int FListDestroy(FList); 226 extern int FListFind(MPI_Comm,FList,const char[],int (**)(void*)); 227 extern int FListPrintTypes(MPI_Comm,FILE*,const char[],const char[],FList); 228 #if defined(USE_DYNAMIC_LIBRARIES) 229 #define FListAdd(a,b,p,c) FListAdd_Private(a,b,p,0) 230 #else 231 #define FListAdd(a,b,p,c) FListAdd_Private(a,b,p,(int (*)(void *))c) 232 #endif 233 extern int FListDuplicate(FList,FList *); 234 235 typedef struct _DLLibraryList *DLLibraryList; 236 extern DLLibraryList DLLibrariesLoaded; 237 extern int DLLibraryOpen(MPI_Comm,const char[],void **); 238 extern int DLLibrarySym(MPI_Comm,DLLibraryList *,const char[],const char[],void **); 239 extern int DLLibraryAppend(MPI_Comm,DLLibraryList *,const char[]); 240 extern int DLLibraryPrepend(MPI_Comm,DLLibraryList *,const char[]); 241 extern int DLLibraryClose(DLLibraryList); 242 extern int DLLibraryPrintPath(); 243 244 /* 245 Mechanism for translating PETSc object representations between languages 246 Note currently used. 247 */ 248 typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage; 249 #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C 250 extern int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *); 251 extern int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **); 252 253 /* 254 Defines the base data structures for all PETSc objects 255 */ 256 #include "petschead.h" 257 258 /* 259 Defines PETSc profiling. 260 */ 261 #include "petsclog.h" 262 263 #if defined(HAVE_AMS) 264 extern PetscTruth PetscAMSPublishAll; 265 #define PetscPublishAll(v)\ 266 { if (PetscAMSPublishAll) { \ 267 int __ierr;\ 268 __ierr = PetscObjectPublish((PetscObject)v);CHKERRQ(__ierr);\ 269 }} 270 #else 271 #define PetscPublishAll(v) 272 #endif 273 274 extern int PetscSequentialPhaseBegin(MPI_Comm,int); 275 extern int PetscSequentialPhaseEnd(MPI_Comm,int); 276 extern int PetscBarrier(PetscObject); 277 extern int PetscMPIDump(FILE*); 278 279 /* 280 This code allows one to pass a MPI communicator between 281 C and Fortran. MPI 2.0 defines a standard API for doing this. 282 The code here is provided to allow PETSc to work with MPI 1.1 283 standard MPI libraries. 284 */ 285 extern int MPICCommToFortranComm(MPI_Comm,int *); 286 extern int MPIFortranCommToCComm(int,MPI_Comm*); 287 288 /* 289 Simple PETSc parallel IO for ASCII printing 290 */ 291 extern int PetscFixFilename(const char[],char[]); 292 extern FILE *PetscFOpen(MPI_Comm,const char[],const char[]); 293 extern int PetscFClose(MPI_Comm,FILE*); 294 extern int PetscFPrintf(MPI_Comm,FILE*,const char[],...); 295 extern int PetscPrintf(MPI_Comm,const char[],...); 296 extern int (*PetscErrorPrintf)(const char[],...); 297 extern int (*PetscHelpPrintf)(MPI_Comm,const char[],...); 298 299 extern int PetscSynchronizedPrintf(MPI_Comm,const char[],...); 300 extern int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...); 301 extern int PetscSynchronizedFlush(MPI_Comm); 302 303 304 /* 305 Simple PETSc object that contains a pointer to any required data 306 */ 307 typedef struct _p_PetscObjectContainer* PetscObjectContainer; 308 extern int PetscObjectContainerGetPointer(PetscObjectContainer,void **); 309 extern int PetscObjectContainerSetPointer(PetscObjectContainer,void *); 310 extern int PetscObjectContainerDestroy(PetscObjectContainer); 311 extern int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *); 312 313 /* 314 For incremental debugging 315 */ 316 extern int PetscCompare; 317 extern int PetscCompareDouble(double); 318 extern int PetscCompareScalar(Scalar); 319 extern int PetscCompareInt(int); 320 321 /* 322 For use in debuggers 323 */ 324 extern int PetscGlobalRank,PetscGlobalSize; 325 extern int PetscIntView(int,int[],Viewer); 326 extern int PetscDoubleView(int,double[],Viewer); 327 328 /* 329 C code optimization is often enhanced by telling the compiler 330 that certain pointer arguments to functions are not aliased to 331 to other arguments. This is not yet ANSI C standard so we define 332 the macro "restrict" to indicate that the variable is not aliased 333 to any other argument. 334 */ 335 #if defined(HAVE_RESTRICT) && !defined(__cplusplus) 336 #define restrict _Restrict 337 #else 338 #define restrict 339 #endif 340 341 /* 342 Determine if some of the kernel computation routines use 343 Fortran (rather than C) for the numerical calculations. On some machines 344 and compilers (like complex numbers) the Fortran version of the routines 345 is faster than the C/C++ versions. 346 */ 347 #if defined(USE_FORTRAN_KERNELS) 348 349 #if !defined(USE_FORTRAN_KERNEL_MULTAIJ) 350 #define USE_FORTRAN_KERNEL_MULTAIJ 351 #endif 352 353 #if !defined(USE_FORTRAN_KERNEL_NORMSQR) 354 #define USE_FORTRAN_KERNEL_NORMSQR 355 #endif 356 357 #if !defined(USE_FORTRAN_KERNEL_MAXPY) 358 #define USE_FORTRAN_KERNEL_MAXPY 359 #endif 360 361 #if !defined(USE_FORTRAN_KERNEL_SOLVEAIJ) 362 #define USE_FORTRAN_KERNEL_SOLVEAIJ 363 #endif 364 365 #if !defined(USE_FORTRAN_KERNEL_SOLVEBAIJ) 366 #define USE_FORTRAN_KERNEL_SOLVEBAIJ 367 #endif 368 369 #if !defined(USE_FORTRAN_KERNEL_MULTADDAIJ) 370 #define USE_FORTRAN_KERNEL_MULTADDAIJ 371 #endif 372 373 #if !defined(USE_FORTRAN_KERNEL_MDOT) 374 #define USE_FORTRAN_KERNEL_MDOT 375 #endif 376 377 #endif 378 379 /* 380 Macros for indicating code that should be compiled with a C interface, 381 rather than a C++ interface. Any routines that are dynamically loaded 382 (such as the PCCreate_XXX() routines) must be wrapped so that the name 383 mangler does not change the functions symbol name 384 */ 385 #if defined(__cplusplus) 386 #define EXTERN_C_BEGIN extern "C" { 387 #define EXTERN_C_END } 388 #else 389 #define EXTERN_C_BEGIN 390 #define EXTERN_C_END 391 #endif 392 393 #endif 394