1 /* $Id: petsc.h,v 1.297 2001/09/07 20:13:16 bsmith Exp $ */ 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 12 */ 13 #include "petscversion.h" 14 15 /* ========================================================================== */ 16 /* 17 petscconf.h is contained in bmake/${PETSC_ARCH}/petscconf.h it is 18 found automatically by the compiler due to the -I${PETSC_DIR}/bmake/${PETSC_ARCH} 19 in the bmake/common_variables definition of PETSC_INCLUDE 20 */ 21 #include "petscconf.h" 22 /* 23 Fixes for configure time choices which impact our interface. Currently only 24 calling conventions and extra compiler checking falls under this category. 25 */ 26 #if !defined(PETSC_PRINTF_FORMAT_CHECK) 27 #define PETSC_PRINTF_FORMAT_CHECK(a,b) 28 #endif 29 #if !defined (PETSC_STDCALL) 30 #define PETSC_STDCALL 31 #endif 32 #if !defined (PETSC_TEMPLATE) 33 #define PETSC_TEMPLATE 34 #endif 35 36 /* ========================================================================== */ 37 38 #include <stdio.h> 39 /* 40 Defines the interface to MPI allowing the use of all MPI functions. 41 */ 42 #include "mpi.h" 43 44 /* 45 EXTERN indicates a PETSc function defined elsewhere 46 */ 47 #if !defined(EXTERN) 48 #define EXTERN extern 49 #endif 50 51 /* 52 Defines some elementary mathematics functions and constants. 53 */ 54 #include "petscmath.h" 55 56 /* 57 Basic PETSc constants 58 */ 59 60 /*E 61 PetscTruth - Logical variable. Actually an integer 62 63 Level: beginner 64 65 E*/ 66 typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth; 67 68 #define PETSC_NULL 0 69 #define PETSC_DECIDE -1 70 #define PETSC_DEFAULT -2 71 72 #define PETSC_YES PETSC_TRUE 73 #define PETSC_NO PETSC_FALSE 74 #define PETSC_IGNORE PETSC_NULL 75 #define PETSC_DETERMINE PETSC_DECIDE 76 77 78 extern MPI_Comm PETSC_COMM_WORLD; 79 extern MPI_Comm PETSC_COMM_SELF; 80 extern PetscTruth PetscInitializeCalled; 81 EXTERN int PetscSetCommWorld(MPI_Comm); 82 EXTERN int PetscSetHelpVersionFunctions(int (*)(MPI_Comm),int (*)(MPI_Comm)); 83 84 /*MC 85 PetscMalloc - Allocates memory 86 87 Input Parameter: 88 . m - number of bytes to allocate 89 90 Output Parameter: 91 . result - memory allocated 92 93 Synopsis: 94 int PetscMalloc(size_t m,void **result) 95 96 Level: beginner 97 98 Notes: Memory is always allocated at least double aligned 99 100 .seealso: PetscFree(), PetscNew() 101 102 Concepts: memory allocation 103 104 M*/ 105 #define PetscMalloc(a,b) (*PetscTrMalloc)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__,(void**)(b)) 106 /*MC 107 PetscNew - Allocates memory of a particular type 108 109 Input Parameter: 110 . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated 111 112 Output Parameter: 113 . result - memory allocated 114 115 Synopsis: 116 int PetscNew(struct type,((type *))result) 117 118 Level: beginner 119 120 .seealso: PetscFree(), PetscMalloc() 121 122 Concepts: memory allocation 123 124 M*/ 125 #define PetscNew(A,b) PetscMalloc(sizeof(A),(b)) 126 /*MC 127 PetscFree - Frees memory 128 129 Input Parameter: 130 . memory - memory to free 131 132 Synopsis: 133 int PetscFree(void *memory) 134 135 Level: beginner 136 137 Notes: Memory must have been obtained with PetscNew() or PetscMalloc() 138 139 .seealso: PetscNew(), PetscMalloc() 140 141 Concepts: memory allocation 142 143 M*/ 144 #define PetscFree(a) (*PetscTrFree)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__) 145 EXTERN int (*PetscTrMalloc)(size_t,int,char*,char*,char*,void**); 146 EXTERN int (*PetscTrFree)(void *,int,char*,char*,char*); 147 EXTERN int PetscSetMalloc(int (*)(size_t,int,char*,char*,char*,void**),int (*)(void *,int,char*,char*,char*)); 148 EXTERN int PetscClearMalloc(void); 149 150 /* 151 Routines for tracing memory corruption/bleeding with default PETSc 152 memory allocation 153 */ 154 EXTERN int PetscTrDump(FILE *); 155 EXTERN int PetscTrSpace(PetscLogDouble *,PetscLogDouble *,PetscLogDouble *); 156 EXTERN int PetscTrValid(int,const char[],const char[],const char[]); 157 EXTERN int PetscTrDebugLevel(int); 158 EXTERN int PetscTrLog(void); 159 EXTERN int PetscTrLogDump(FILE *); 160 EXTERN int PetscGetResidentSetSize(PetscLogDouble *); 161 162 /* 163 Variable type where we stash PETSc object pointers in Fortran. 164 Assumes that sizeof(long) == sizeof(void*)which is true on 165 all machines that we know. 166 */ 167 #define PetscFortranAddr long 168 169 /*E 170 PetscDataType - Used for handling different basic data types. 171 172 Level: beginner 173 174 .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(), 175 PetscDataTypeGetSize(), PetscDataTypeGetName() 176 177 E*/ 178 typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2, 179 PETSC_LONG =3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5, 180 PETSC_CHAR = 6,PETSC_LOGICAL = 7} PetscDataType; 181 #if defined(PETSC_USE_COMPLEX) 182 #define PETSC_SCALAR PETSC_COMPLEX 183 #else 184 #if defined(PETSC_USE_SINGLE) 185 #define PETSC_SCALAR PETSC_FLOAT 186 #else 187 #define PETSC_SCALAR PETSC_DOUBLE 188 #endif 189 #endif 190 #if defined(PETSC_USE_SINGLE) 191 #define PETSC_REAL PETSC_FLOAT 192 #else 193 #define PETSC_REAL PETSC_DOUBLE 194 #endif 195 #define PETSC_FORTRANADDR PETSC_LONG 196 197 EXTERN int PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*); 198 EXTERN int PetscDataTypeGetSize(PetscDataType,int*); 199 EXTERN int PetscDataTypeGetName(PetscDataType,char*[]); 200 201 /* 202 Basic memory and string operations. These are usually simple wrappers 203 around the basic Unix system calls, but a few of them have additional 204 functionality and/or error checking. 205 */ 206 EXTERN int PetscMemcpy(void *,const void *,int); 207 EXTERN int PetscBitMemcpy(void*,int,const void*,int,int,PetscDataType); 208 EXTERN int PetscMemmove(void *,void *,int); 209 EXTERN int PetscMemzero(void *,int); 210 EXTERN int PetscMemcmp(const void*,const void*,int,PetscTruth *); 211 EXTERN int PetscStrlen(const char[],int*); 212 EXTERN int PetscStrcmp(const char[],const char[],PetscTruth *); 213 EXTERN int PetscStrgrt(const char[],const char[],PetscTruth *); 214 EXTERN int PetscStrcasecmp(const char[],const char[],PetscTruth*); 215 EXTERN int PetscStrncmp(const char[],const char[],int,PetscTruth*); 216 EXTERN int PetscStrcpy(char[],const char[]); 217 EXTERN int PetscStrcat(char[],const char[]); 218 EXTERN int PetscStrncat(char[],const char[],int); 219 EXTERN int PetscStrncpy(char[],const char[],int); 220 EXTERN int PetscStrchr(const char[],char,char **); 221 EXTERN int PetscStrtolower(char[]); 222 EXTERN int PetscStrrchr(const char[],char,char **); 223 EXTERN int PetscStrstr(const char[],const char[],char **); 224 EXTERN int PetscStrallocpy(const char[],char **); 225 EXTERN int PetscStrreplace(MPI_Comm,const char[],char*,int); 226 #define PetscStrfree(a) ((a) ? PetscFree(a) : 0) 227 typedef struct {char token;char *array;char *current;} PetscToken; 228 EXTERN int PetscTokenCreate(const char[],const char,PetscToken**); 229 EXTERN int PetscTokenFind(PetscToken*,char **); 230 EXTERN int PetscTokenDestroy(PetscToken*); 231 232 /* 233 These are MPI operations for MPI_Allreduce() etc 234 */ 235 EXTERN MPI_Op PetscMaxSum_Op; 236 #if defined(PETSC_USE_COMPLEX) 237 EXTERN MPI_Op PetscSum_Op; 238 #else 239 #define PetscSum_Op MPI_SUM 240 #endif 241 242 /*S 243 PetscObject - any PETSc object, PetscViewer, Mat, Vec, SLES etc 244 245 Level: beginner 246 247 .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName() 248 S*/ 249 typedef struct _p_PetscObject* PetscObject; 250 251 /*S 252 PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed 253 by string name 254 255 Level: advanced 256 257 .seealso: PetscFListAdd(), PetscFListDestroy() 258 S*/ 259 typedef struct _PetscFList *PetscFList; 260 261 #include "petscviewer.h" 262 #include "petscoptions.h" 263 264 EXTERN int PetscShowMemoryUsage(PetscViewer,char*); 265 EXTERN int PetscGetTime(PetscLogDouble*); 266 EXTERN int PetscGetCPUTime(PetscLogDouble*); 267 EXTERN int PetscSleep(int); 268 269 /* 270 Initialization of PETSc 271 */ 272 EXTERN int PetscInitialize(int*,char***,char[],const char[]); 273 EXTERN int PetscInitializeNoArguments(void); 274 EXTERN int PetscFinalize(void); 275 EXTERN int PetscInitializeFortran(void); 276 EXTERN int PetscGetArgs(int*,char ***); 277 EXTERN int PetscEnd(void); 278 279 /* 280 ParameterDict is an abstraction for arguments to interface mechanisms 281 */ 282 extern int DICT_COOKIE; 283 typedef struct _p_Dict *ParameterDict; 284 285 typedef void (**PetscVoidFunction)(void); 286 287 /* 288 PetscTryMethod - Queries an object for a method, if it exists then calls it. 289 Can support argument checking 290 */ 291 #if defined(PETSC_FORTRAN_STUBS) 292 #define PetscTryMethod(obj,A,B,C) \ 293 0;{ int (*f)B; \ 294 *ierr = PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);if (*ierr) return; \ 295 if (f) {*ierr = (*f)C;if (*ierr) return;}\ 296 } 297 #else 298 #define PetscTryMethod(obj,A,B,C) \ 299 0;{ int (*f)B, __ierr; \ 300 __ierr = PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);CHKERRQ(__ierr); \ 301 if (f) {__ierr = (*f)C;CHKERRQ(__ierr);}\ 302 } 303 #endif 304 305 /* 306 Functions that can act on any PETSc object. 307 */ 308 EXTERN int PetscObjectDestroy(PetscObject); 309 EXTERN int PetscObjectExists(PetscObject,PetscTruth*); 310 EXTERN int PetscObjectGetComm(PetscObject,MPI_Comm *); 311 EXTERN int PetscObjectGetCookie(PetscObject,int *); 312 EXTERN int PetscObjectGetType(PetscObject,int *); 313 EXTERN int PetscObjectSetName(PetscObject,const char[]); 314 EXTERN int PetscObjectGetName(PetscObject,char*[]); 315 EXTERN int PetscObjectReference(PetscObject); 316 EXTERN int PetscObjectGetReference(PetscObject,int*); 317 EXTERN int PetscObjectDereference(PetscObject); 318 EXTERN int PetscObjectGetNewTag(PetscObject,int *); 319 EXTERN int PetscObjectSetParameterDict(PetscObject,ParameterDict); 320 EXTERN int PetscObjectGetParameterDict(PetscObject,ParameterDict*); 321 EXTERN int PetscCommGetNewTag(MPI_Comm,int *); 322 EXTERN int PetscObjectView(PetscObject,PetscViewer); 323 EXTERN int PetscObjectCompose(PetscObject,const char[],PetscObject); 324 EXTERN int PetscObjectQuery(PetscObject,const char[],PetscObject *); 325 EXTERN int PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)(void)); 326 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 327 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0) 328 #else 329 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(void (*)(void))(d)) 330 #endif 331 EXTERN int PetscObjectQueryFunction(PetscObject,const char[],void (**)(void)); 332 EXTERN int PetscObjectSetOptionsPrefix(PetscObject,const char[]); 333 EXTERN int PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 334 EXTERN int PetscObjectPrependOptionsPrefix(PetscObject,const char[]); 335 EXTERN int PetscObjectGetOptionsPrefix(PetscObject,char*[]); 336 EXTERN int PetscObjectPublish(PetscObject); 337 EXTERN int PetscObjectChangeTypeName(PetscObject,char *); 338 EXTERN int PetscObjectChangeSerializeName(PetscObject,char *); 339 EXTERN int PetscObjectRegisterDestroy(PetscObject); 340 EXTERN int PetscObjectRegisterDestroyAll(void); 341 EXTERN int PetscObjectName(PetscObject); 342 EXTERN int PetscTypeCompare(PetscObject,char*,PetscTruth*); 343 EXTERN int PetscSerializeCompare(PetscObject,char*,PetscTruth*); 344 345 /* 346 Defines PETSc error handling. 347 */ 348 #include "petscerror.h" 349 350 /*S 351 PetscOList - Linked list of PETSc objects, accessable by string name 352 353 Level: advanced 354 355 .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind() 356 S*/ 357 typedef struct _PetscOList *PetscOList; 358 359 EXTERN int PetscOListDestroy(PetscOList *); 360 EXTERN int PetscOListFind(PetscOList,const char[],PetscObject*); 361 EXTERN int PetscOListReverseFind(PetscOList,PetscObject,char**); 362 EXTERN int PetscOListAdd(PetscOList *,const char[],PetscObject); 363 EXTERN int PetscOListDuplicate(PetscOList,PetscOList *); 364 365 /* 366 Dynamic library lists. Lists of names of routines in dynamic 367 link libraries that will be loaded as needed. 368 */ 369 EXTERN int PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void)); 370 EXTERN int PetscFListDestroy(PetscFList*); 371 EXTERN int PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)(void)); 372 EXTERN int PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],char *,char *,PetscFList); 373 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 374 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0) 375 #else 376 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c) 377 #endif 378 EXTERN int PetscFListDuplicate(PetscFList,PetscFList *); 379 EXTERN int PetscFListView(PetscFList,PetscViewer); 380 EXTERN int PetscFListConcat(const char [],const char [],char []); 381 EXTERN int PetscFListGet(PetscFList,char ***,int*); 382 383 /*S 384 PetscDLLibraryList - Linked list of dynamics libraries to search for functions 385 386 Level: advanced 387 388 PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries 389 390 .seealso: PetscDLLibraryOpen() 391 S*/ 392 typedef struct _PetscDLLibraryList *PetscDLLibraryList; 393 extern PetscDLLibraryList DLLibrariesLoaded; 394 EXTERN int PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *); 395 EXTERN int PetscDLLibraryOpen(MPI_Comm,const char[],void **); 396 EXTERN int PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **); 397 EXTERN int PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]); 398 EXTERN int PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]); 399 EXTERN int PetscDLLibraryClose(PetscDLLibraryList); 400 EXTERN int PetscDLLibraryPrintPath(void); 401 EXTERN int PetscDLLibraryGetInfo(void *,char *,char **); 402 403 /* 404 Mechanism for translating PETSc object representations between languages 405 Not currently used. 406 */ 407 typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage; 408 #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C 409 EXTERN int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *); 410 EXTERN int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **); 411 412 /* 413 Useful utility routines 414 */ 415 EXTERN int PetscSplitOwnership(MPI_Comm,int*,int*); 416 EXTERN int PetscSplitOwnershipBlock(MPI_Comm,int,int*,int*); 417 EXTERN int PetscSequentialPhaseBegin(MPI_Comm,int); 418 EXTERN int PetscSequentialPhaseEnd(MPI_Comm,int); 419 EXTERN int PetscBarrier(PetscObject); 420 EXTERN int PetscMPIDump(FILE*); 421 422 #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE) 423 /* 424 Defines basic graphics available from PETSc. 425 */ 426 #include "petscdraw.h" 427 428 /* 429 Defines the base data structures for all PETSc objects 430 */ 431 #include "petschead.h" 432 433 /* 434 Defines PETSc profiling. 435 */ 436 #include "petsclog.h" 437 438 /* 439 For locking, unlocking and destroying AMS memories associated with 440 PETSc objects 441 */ 442 #if defined(PETSC_HAVE_AMS) 443 444 extern PetscTruth PetscAMSPublishAll; 445 #define PetscPublishAll(v) (PetscAMSPublishAll ? PetscObjectPublish((PetscObject)v) : 0) 446 #define PetscObjectTakeAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_take_access(((PetscObject)(obj))->amem)) 447 #define PetscObjectGrantAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_grant_access(((PetscObject)(obj))->amem)) 448 #define PetscObjectDepublish(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_destroy(((PetscObject)(obj))->amem)); \ 449 ((PetscObject)(obj))->amem = -1; 450 451 #else 452 453 #define PetscPublishAll(v) 0 454 #define PetscObjectTakeAccess(obj) 0 455 #define PetscObjectGrantAccess(obj) 0 456 #define PetscObjectDepublish(obj) 0 457 458 #endif 459 460 461 462 /* 463 This code allows one to pass a MPI communicator between 464 C and Fortran. MPI 2.0 defines a standard API for doing this. 465 The code here is provided to allow PETSc to work with MPI 1.1 466 standard MPI libraries. 467 */ 468 EXTERN int MPICCommToFortranComm(MPI_Comm,int *); 469 EXTERN int MPIFortranCommToCComm(int,MPI_Comm*); 470 471 /* 472 Simple PETSc parallel IO for ASCII printing 473 */ 474 EXTERN int PetscFixFilename(const char[],char[]); 475 EXTERN int PetscFOpen(MPI_Comm,const char[],const char[],FILE**); 476 EXTERN int PetscFClose(MPI_Comm,FILE*); 477 EXTERN int PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 478 EXTERN int PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 479 EXTERN int (*PetscErrorPrintf)(const char[],...); 480 EXTERN int (*PetscHelpPrintf)(MPI_Comm,const char[],...); 481 EXTERN int PetscPOpen(MPI_Comm,char *,char*,const char[],FILE **); 482 EXTERN int PetscPClose(MPI_Comm,FILE*); 483 EXTERN int PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 484 EXTERN int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 485 EXTERN int PetscSynchronizedFlush(MPI_Comm); 486 EXTERN int PetscSynchronizedFGets(MPI_Comm,FILE*,int,char[]); 487 EXTERN int PetscStartMatlab(MPI_Comm,char *,char*,FILE**); 488 EXTERN int PetscStartJava(MPI_Comm,char *,char*,FILE**); 489 EXTERN int PetscGetPetscDir(char**); 490 491 EXTERN int PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*); 492 /*S 493 PetscObjectContainer - Simple PETSc object that contains a pointer to any required data 494 495 Level: advanced 496 497 .seealso: PetscObject, PetscObjectContainerCreate() 498 S*/ 499 typedef struct _p_PetscObjectContainer* PetscObjectContainer; 500 EXTERN int PetscObjectContainerGetPointer(PetscObjectContainer,void **); 501 EXTERN int PetscObjectContainerSetPointer(PetscObjectContainer,void *); 502 EXTERN int PetscObjectContainerDestroy(PetscObjectContainer); 503 EXTERN int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *); 504 505 /* 506 For incremental debugging 507 */ 508 extern PetscTruth PetscCompare; 509 EXTERN int PetscCompareDouble(double); 510 EXTERN int PetscCompareScalar(PetscScalar); 511 EXTERN int PetscCompareInt(int); 512 513 /* 514 For use in debuggers 515 */ 516 extern int PetscGlobalRank,PetscGlobalSize; 517 EXTERN int PetscIntView(int,int[],PetscViewer); 518 EXTERN int PetscRealView(int,PetscReal[],PetscViewer); 519 EXTERN int PetscScalarView(int,PetscScalar[],PetscViewer); 520 521 /* 522 Allows accessing Matlab Engine 523 */ 524 #include "petscengine.h" 525 526 /* 527 C code optimization is often enhanced by telling the compiler 528 that certain pointer arguments to functions are not aliased to 529 to other arguments. This is not yet ANSI C standard so we define 530 the macro "restrict" to indicate that the variable is not aliased 531 to any other argument. 532 */ 533 #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus) 534 #define restrict _Restrict 535 #else 536 #if defined(restrict) 537 #undef restrict 538 #endif 539 #define restrict 540 #endif 541 542 /* 543 Determine if some of the kernel computation routines use 544 Fortran (rather than C) for the numerical calculations. On some machines 545 and compilers (like complex numbers) the Fortran version of the routines 546 is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS 547 would be set in the petscconf.h file 548 */ 549 #if defined(PETSC_USE_FORTRAN_KERNELS) 550 551 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 552 #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 553 #endif 554 555 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 556 #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 557 #endif 558 559 #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM) 560 #define PETSC_USE_FORTRAN_KERNEL_NORM 561 #endif 562 563 #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 564 #define PETSC_USE_FORTRAN_KERNEL_MAXPY 565 #endif 566 567 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 568 #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 569 #endif 570 571 #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 572 #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 573 #endif 574 575 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 576 #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 577 #endif 578 579 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 580 #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 581 #endif 582 583 #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 584 #define PETSC_USE_FORTRAN_KERNEL_MDOT 585 #endif 586 587 #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 588 #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 589 #endif 590 591 #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX) 592 #define PETSC_USE_FORTRAN_KERNEL_AYPX 593 #endif 594 595 #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY) 596 #define PETSC_USE_FORTRAN_KERNEL_WAXPY 597 #endif 598 599 #endif 600 601 /* 602 Macros for indicating code that should be compiled with a C interface, 603 rather than a C++ interface. Any routines that are dynamically loaded 604 (such as the PCCreate_XXX() routines) must be wrapped so that the name 605 mangler does not change the functions symbol name. This just hides the 606 ugly extern "C" {} wrappers. 607 */ 608 #if defined(__cplusplus) 609 #define EXTERN_C_BEGIN extern "C" { 610 #define EXTERN_C_END } 611 #else 612 #define EXTERN_C_BEGIN 613 #define EXTERN_C_END 614 #endif 615 616 /* --------------------------------------------------------------------*/ 617 618 /*M 619 size - integer variable used to contain the number of processors in 620 the relevent MPI_Comm 621 622 Level: beginner 623 624 .seealso: rank, comm 625 M*/ 626 627 /*M 628 rank - integer variable used to contain the number of this processor relative 629 to all in the relevent MPI_Comm 630 631 Level: beginner 632 633 .seealso: size, comm 634 M*/ 635 636 /*M 637 comm - MPI_Comm used in the current routine or object 638 639 Level: beginner 640 641 .seealso: size, rank 642 M*/ 643 644 /*M 645 PetscScalar - PETSc type that represents either a double precision real number or 646 a double precision complex number if the code is compiled with BOPT=g_complex or O_complex 647 648 Level: beginner 649 650 M*/ 651 652 /* 653 The IBM include files define hz, here we hide it so that it may be used 654 as a regular user variable. 655 */ 656 #if defined(hz) 657 #undef hz 658 #endif 659 660 /* For arrays that contain filenames or paths */ 661 662 #if defined(PETSC_HAVE_LIMITS_H) 663 #include <limits.h> 664 #endif 665 #if defined(PETSC_HAVE_SYS_PARAM_H) 666 #include <sys/param.h> 667 #endif 668 669 #if defined(MAXPATHLEN) 670 # define PETSC_MAX_PATH_LEN MAXPATHLEN 671 #elif defined(MAX_PATH) 672 # define PETSC_MAX_PATH_LEN MAX_PATH 673 #elif defined(_MAX_PATH) 674 # define PETSC_MAX_PATH_LEN _MAX_PATH 675 #else 676 # define PETSC_MAX_PATH_LEN 4096 677 #endif 678 679 #endif 680 681 682