1 /* $Id: petsc.h,v 1.234 1998/12/17 22:13:20 bsmith 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 #define PetscTypeCompare(a,b) (!PetscStrcmp((char*)(a),(char *)(b))) 129 130 /* 131 Basic PETSc constants 132 */ 133 typedef enum { PETSC_FALSE, PETSC_TRUE } PetscTruth; 134 #define PETSC_NULL 0 135 #define PETSC_DECIDE -1 136 #define PETSC_DETERMINE PETSC_DECIDE 137 #define PETSC_DEFAULT -2 138 139 /* 140 Each PETSc object class has it's own cookie (internal integer in the 141 data structure used for error checking). These are all defined by an offset 142 from the lowest one, PETSC_COOKIE. If you increase these you must 143 increase the field sizes in petsc/src/plog/src/plog.c 144 */ 145 #define PETSC_COOKIE 1211211 146 #define LARGEST_PETSC_COOKIE_PREDEFINED PETSC_COOKIE + 30 147 #define LARGEST_PETSC_COOKIE_ALLOWED PETSC_COOKIE + 50 148 extern int LARGEST_PETSC_COOKIE; 149 150 #include "viewer.h" 151 #include "options.h" 152 153 /* 154 Defines basic graphics available from PETSc. 155 */ 156 #include "draw.h" 157 158 extern int PetscGetTime(PLogDouble*); 159 extern int PetscGetCPUTime(PLogDouble*); 160 extern int PetscSleep(int); 161 162 /* 163 Initialization of PETSc or its micro-kernel ALICE 164 */ 165 extern int AliceInitialize(int*,char***,const char[],const char[]); 166 extern int AliceInitializeNoArguments(void); 167 extern int AliceFinalize(void); 168 extern void AliceInitializeFortran(void); 169 170 extern int PetscInitialize(int*,char***,char[],const char[]); 171 extern int PetscInitializeNoArguments(void); 172 extern int PetscFinalize(void); 173 extern void PetscInitializeFortran(void); 174 175 /* 176 Functions that can act on any PETSc object. 177 */ 178 typedef struct _p_PetscObject* PetscObject; 179 extern int PetscObjectDestroy(PetscObject); 180 extern int PetscObjectExists(PetscObject,int*); 181 extern int PetscObjectGetComm(PetscObject,MPI_Comm *comm); 182 extern int PetscObjectGetCookie(PetscObject,int *cookie); 183 extern int PetscObjectGetType(PetscObject,int *type); 184 extern int PetscObjectSetName(PetscObject,const char[]); 185 extern int PetscObjectGetName(PetscObject,char*[]); 186 extern int PetscObjectReference(PetscObject); 187 extern int PetscObjectGetReference(PetscObject,int*); 188 extern int PetscObjectDereference(PetscObject); 189 extern int PetscObjectGetNewTag(PetscObject,int *); 190 extern int PetscObjectRestoreNewTag(PetscObject,int *); 191 extern int PetscObjectView(PetscObject,Viewer); 192 extern int PetscObjectCompose(PetscObject,const char[],PetscObject); 193 extern int PetscObjectQuery(PetscObject,const char[],PetscObject *); 194 extern int PetscObjectComposeFunction_Private(PetscObject,const char[],const char[],void *); 195 #if defined(USE_DYNAMIC_LIBRARIES) 196 #define PetscObjectComposeFunction(a,b,c,d) PetscObjectComposeFunction_Private(a,b,c,0) 197 #else 198 #define PetscObjectComposeFunction(a,b,c,d) PetscObjectComposeFunction_Private(a,b,c,d) 199 #endif 200 extern int PetscObjectQueryFunction(PetscObject,const char[],void **); 201 extern int PetscObjectSetOptionsPrefix(PetscObject,const char[]); 202 extern int PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 203 extern int PetscObjectPrependOptionsPrefix(PetscObject,const char[]); 204 extern int PetscObjectGetOptionsPrefix(PetscObject,char*[]); 205 extern int PetscObjectPublish(PetscObject); 206 207 /* 208 Defines PETSc error handling. 209 */ 210 #include "petscerror.h" 211 212 /* 213 Mechanism for managing lists of objects attached (composed) with 214 a PETSc object. 215 */ 216 typedef struct _OList *OList; 217 extern int OListDestroy(OList *); 218 extern int OListFind(OList,const char[],PetscObject*); 219 extern int OListAdd(OList *,const char[],PetscObject); 220 extern int OListDuplicate(OList,OList *); 221 222 /* 223 Dynamic library lists. Lists of names of routines in dynamic 224 link libraries that will be loaded as needed. 225 */ 226 typedef struct _FList *FList; 227 extern int FListAdd_Private(FList*,const char[],const char[],int (*)(void *)); 228 extern int FListDestroy(FList); 229 extern int FListFind(MPI_Comm,FList,const char[],int (**)(void*)); 230 extern int FListPrintTypes(MPI_Comm,FILE*,const char[],const char[],FList); 231 #if defined(USE_DYNAMIC_LIBRARIES) 232 #define FListAdd(a,b,p,c) FListAdd_Private(a,b,p,0) 233 #else 234 #define FListAdd(a,b,p,c) FListAdd_Private(a,b,p,(int (*)(void *))c) 235 #endif 236 extern int FListDuplicate(FList,FList *); 237 extern int FListView(FList,Viewer); 238 239 typedef struct _DLLibraryList *DLLibraryList; 240 extern DLLibraryList DLLibrariesLoaded; 241 extern int DLLibraryOpen(MPI_Comm,const char[],void **); 242 extern int DLLibrarySym(MPI_Comm,DLLibraryList *,const char[],const char[],void **); 243 extern int DLLibraryAppend(MPI_Comm,DLLibraryList *,const char[]); 244 extern int DLLibraryPrepend(MPI_Comm,DLLibraryList *,const char[]); 245 extern int DLLibraryClose(DLLibraryList); 246 extern int DLLibraryPrintPath(); 247 248 /* 249 Mechanism for translating PETSc object representations between languages 250 Note currently used. 251 */ 252 typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage; 253 #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C 254 extern int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *); 255 extern int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **); 256 257 /* 258 Defines the base data structures for all PETSc objects 259 */ 260 #include "petschead.h" 261 262 /* 263 Defines PETSc profiling. 264 */ 265 #include "petsclog.h" 266 267 #if defined(HAVE_AMS) 268 extern PetscTruth PetscAMSPublishAll; 269 #define PetscPublishAll(v)\ 270 { if (PetscAMSPublishAll) { \ 271 int __ierr;\ 272 __ierr = PetscObjectPublish((PetscObject)v);CHKERRQ(__ierr);\ 273 }} 274 #else 275 #define PetscPublishAll(v) 276 #endif 277 278 extern int PetscSequentialPhaseBegin(MPI_Comm,int); 279 extern int PetscSequentialPhaseEnd(MPI_Comm,int); 280 extern int PetscBarrier(PetscObject); 281 extern int PetscMPIDump(FILE*); 282 283 /* 284 This code allows one to pass a MPI communicator between 285 C and Fortran. MPI 2.0 defines a standard API for doing this. 286 The code here is provided to allow PETSc to work with MPI 1.1 287 standard MPI libraries. 288 */ 289 extern int MPICCommToFortranComm(MPI_Comm,int *); 290 extern int MPIFortranCommToCComm(int,MPI_Comm*); 291 292 /* 293 Simple PETSc parallel IO for ASCII printing 294 */ 295 extern int PetscFixFilename(const char[],char[]); 296 extern FILE *PetscFOpen(MPI_Comm,const char[],const char[]); 297 extern int PetscFClose(MPI_Comm,FILE*); 298 extern int PetscFPrintf(MPI_Comm,FILE*,const char[],...); 299 extern int PetscPrintf(MPI_Comm,const char[],...); 300 extern int (*PetscErrorPrintf)(const char[],...); 301 extern int (*PetscHelpPrintf)(MPI_Comm,const char[],...); 302 303 extern int PetscSynchronizedPrintf(MPI_Comm,const char[],...); 304 extern int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...); 305 extern int PetscSynchronizedFlush(MPI_Comm); 306 307 308 /* 309 Simple PETSc object that contains a pointer to any required data 310 */ 311 typedef struct _p_PetscObjectContainer* PetscObjectContainer; 312 extern int PetscObjectContainerGetPointer(PetscObjectContainer,void **); 313 extern int PetscObjectContainerSetPointer(PetscObjectContainer,void *); 314 extern int PetscObjectContainerDestroy(PetscObjectContainer); 315 extern int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *); 316 317 /* 318 For incremental debugging 319 */ 320 extern int PetscCompare; 321 extern int PetscCompareDouble(double); 322 extern int PetscCompareScalar(Scalar); 323 extern int PetscCompareInt(int); 324 325 /* 326 For use in debuggers 327 */ 328 extern int PetscGlobalRank,PetscGlobalSize; 329 extern int PetscIntView(int,int[],Viewer); 330 extern int PetscDoubleView(int,double[],Viewer); 331 extern int PetscScalarView(int,Scalar[],Viewer); 332 333 /* 334 C code optimization is often enhanced by telling the compiler 335 that certain pointer arguments to functions are not aliased to 336 to other arguments. This is not yet ANSI C standard so we define 337 the macro "restrict" to indicate that the variable is not aliased 338 to any other argument. 339 */ 340 #if defined(HAVE_RESTRICT) && !defined(__cplusplus) 341 #define restrict _Restrict 342 #else 343 #define restrict 344 #endif 345 346 /* 347 Determine if some of the kernel computation routines use 348 Fortran (rather than C) for the numerical calculations. On some machines 349 and compilers (like complex numbers) the Fortran version of the routines 350 is faster than the C/C++ versions. 351 */ 352 #if defined(USE_FORTRAN_KERNELS) 353 354 #if !defined(USE_FORTRAN_KERNEL_MULTAIJ) 355 #define USE_FORTRAN_KERNEL_MULTAIJ 356 #endif 357 358 #if !defined(USE_FORTRAN_KERNEL_NORMSQR) 359 #define USE_FORTRAN_KERNEL_NORMSQR 360 #endif 361 362 #if !defined(USE_FORTRAN_KERNEL_MAXPY) 363 #define USE_FORTRAN_KERNEL_MAXPY 364 #endif 365 366 #if !defined(USE_FORTRAN_KERNEL_SOLVEAIJ) 367 #define USE_FORTRAN_KERNEL_SOLVEAIJ 368 #endif 369 370 #if !defined(USE_FORTRAN_KERNEL_SOLVEBAIJ) 371 #define USE_FORTRAN_KERNEL_SOLVEBAIJ 372 #endif 373 374 #if !defined(USE_FORTRAN_KERNEL_MULTADDAIJ) 375 #define USE_FORTRAN_KERNEL_MULTADDAIJ 376 #endif 377 378 #if !defined(USE_FORTRAN_KERNEL_MDOT) 379 #define USE_FORTRAN_KERNEL_MDOT 380 #endif 381 382 #endif 383 384 /* 385 Macros for indicating code that should be compiled with a C interface, 386 rather than a C++ interface. Any routines that are dynamically loaded 387 (such as the PCCreate_XXX() routines) must be wrapped so that the name 388 mangler does not change the functions symbol name 389 */ 390 #if defined(__cplusplus) 391 #define EXTERN_C_BEGIN extern "C" { 392 #define EXTERN_C_END } 393 #else 394 #define EXTERN_C_BEGIN 395 #define EXTERN_C_END 396 #endif 397 398 #endif 399