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 EXTERN int PetscMaxSum(MPI_Comm,const int[],int*,int*); 242 243 /*S 244 PetscObject - any PETSc object, PetscViewer, Mat, Vec, SLES etc 245 246 Level: beginner 247 248 .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName() 249 S*/ 250 typedef struct _p_PetscObject* PetscObject; 251 252 /*S 253 PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed 254 by string name 255 256 Level: advanced 257 258 .seealso: PetscFListAdd(), PetscFListDestroy() 259 S*/ 260 typedef struct _PetscFList *PetscFList; 261 262 #include "petscviewer.h" 263 #include "petscoptions.h" 264 265 EXTERN int PetscShowMemoryUsage(PetscViewer,char*); 266 EXTERN int PetscGetTime(PetscLogDouble*); 267 EXTERN int PetscGetCPUTime(PetscLogDouble*); 268 EXTERN int PetscSleep(int); 269 270 /* 271 Initialization of PETSc 272 */ 273 EXTERN int PetscInitialize(int*,char***,char[],const char[]); 274 EXTERN int PetscInitializeNoArguments(void); 275 EXTERN int PetscFinalize(void); 276 EXTERN int PetscInitializeFortran(void); 277 EXTERN int PetscGetArgs(int*,char ***); 278 EXTERN int PetscEnd(void); 279 280 /* 281 ParameterDict is an abstraction for arguments to interface mechanisms 282 */ 283 extern int DICT_COOKIE; 284 typedef struct _p_Dict *ParameterDict; 285 286 typedef void (**PetscVoidFunction)(void); 287 288 /* 289 PetscTryMethod - Queries an object for a method, if it exists then calls it. 290 Can support argument checking 291 */ 292 #if defined(PETSC_FORTRAN_STUBS) 293 #define PetscTryMethod(obj,A,B,C) \ 294 0;{ int (*f)B; \ 295 *ierr = PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);if (*ierr) return; \ 296 if (f) {*ierr = (*f)C;if (*ierr) return;}\ 297 } 298 #else 299 #define PetscTryMethod(obj,A,B,C) \ 300 0;{ int (*f)B, __ierr; \ 301 __ierr = PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);CHKERRQ(__ierr); \ 302 if (f) {__ierr = (*f)C;CHKERRQ(__ierr);}\ 303 } 304 #endif 305 306 /* 307 Functions that can act on any PETSc object. 308 */ 309 EXTERN int PetscObjectDestroy(PetscObject); 310 EXTERN int PetscObjectExists(PetscObject,PetscTruth*); 311 EXTERN int PetscObjectGetComm(PetscObject,MPI_Comm *); 312 EXTERN int PetscObjectGetCookie(PetscObject,int *); 313 EXTERN int PetscObjectGetType(PetscObject,int *); 314 EXTERN int PetscObjectSetName(PetscObject,const char[]); 315 EXTERN int PetscObjectGetName(PetscObject,char*[]); 316 EXTERN int PetscObjectReference(PetscObject); 317 EXTERN int PetscObjectGetReference(PetscObject,int*); 318 EXTERN int PetscObjectDereference(PetscObject); 319 EXTERN int PetscObjectGetNewTag(PetscObject,int *); 320 EXTERN int PetscObjectSetParameterDict(PetscObject,ParameterDict); 321 EXTERN int PetscObjectGetParameterDict(PetscObject,ParameterDict*); 322 EXTERN int PetscCommGetNewTag(MPI_Comm,int *); 323 EXTERN int PetscObjectView(PetscObject,PetscViewer); 324 EXTERN int PetscObjectCompose(PetscObject,const char[],PetscObject); 325 EXTERN int PetscObjectQuery(PetscObject,const char[],PetscObject *); 326 EXTERN int PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)(void)); 327 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 328 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0) 329 #else 330 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(void (*)(void))(d)) 331 #endif 332 EXTERN int PetscObjectQueryFunction(PetscObject,const char[],void (**)(void)); 333 EXTERN int PetscObjectSetOptionsPrefix(PetscObject,const char[]); 334 EXTERN int PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 335 EXTERN int PetscObjectPrependOptionsPrefix(PetscObject,const char[]); 336 EXTERN int PetscObjectGetOptionsPrefix(PetscObject,char*[]); 337 EXTERN int PetscObjectPublish(PetscObject); 338 EXTERN int PetscObjectChangeTypeName(PetscObject,char *); 339 EXTERN int PetscObjectChangeSerializeName(PetscObject,char *); 340 EXTERN int PetscObjectRegisterDestroy(PetscObject); 341 EXTERN int PetscObjectRegisterDestroyAll(void); 342 EXTERN int PetscObjectName(PetscObject); 343 EXTERN int PetscTypeCompare(PetscObject,char*,PetscTruth*); 344 EXTERN int PetscSerializeCompare(PetscObject,char*,PetscTruth*); 345 346 /* 347 Defines PETSc error handling. 348 */ 349 #include "petscerror.h" 350 351 /*S 352 PetscOList - Linked list of PETSc objects, accessable by string name 353 354 Level: advanced 355 356 .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind() 357 S*/ 358 typedef struct _PetscOList *PetscOList; 359 360 EXTERN int PetscOListDestroy(PetscOList *); 361 EXTERN int PetscOListFind(PetscOList,const char[],PetscObject*); 362 EXTERN int PetscOListReverseFind(PetscOList,PetscObject,char**); 363 EXTERN int PetscOListAdd(PetscOList *,const char[],PetscObject); 364 EXTERN int PetscOListDuplicate(PetscOList,PetscOList *); 365 366 /* 367 Dynamic library lists. Lists of names of routines in dynamic 368 link libraries that will be loaded as needed. 369 */ 370 EXTERN int PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void)); 371 EXTERN int PetscFListDestroy(PetscFList*); 372 EXTERN int PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)(void)); 373 EXTERN int PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],char *,char *,PetscFList); 374 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 375 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0) 376 #else 377 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c) 378 #endif 379 EXTERN int PetscFListDuplicate(PetscFList,PetscFList *); 380 EXTERN int PetscFListView(PetscFList,PetscViewer); 381 EXTERN int PetscFListConcat(const char [],const char [],char []); 382 EXTERN int PetscFListGet(PetscFList,char ***,int*); 383 384 /*S 385 PetscDLLibraryList - Linked list of dynamics libraries to search for functions 386 387 Level: advanced 388 389 PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries 390 391 .seealso: PetscDLLibraryOpen() 392 S*/ 393 typedef struct _PetscDLLibraryList *PetscDLLibraryList; 394 extern PetscDLLibraryList DLLibrariesLoaded; 395 EXTERN int PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *); 396 EXTERN int PetscDLLibraryOpen(MPI_Comm,const char[],void **); 397 EXTERN int PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **); 398 EXTERN int PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]); 399 EXTERN int PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]); 400 EXTERN int PetscDLLibraryClose(PetscDLLibraryList); 401 EXTERN int PetscDLLibraryPrintPath(void); 402 EXTERN int PetscDLLibraryGetInfo(void *,char *,char **); 403 404 /* 405 Mechanism for translating PETSc object representations between languages 406 Not currently used. 407 */ 408 typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage; 409 #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C 410 EXTERN int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *); 411 EXTERN int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **); 412 413 /* 414 Useful utility routines 415 */ 416 EXTERN int PetscSplitOwnership(MPI_Comm,int*,int*); 417 EXTERN int PetscSplitOwnershipBlock(MPI_Comm,int,int*,int*); 418 EXTERN int PetscSequentialPhaseBegin(MPI_Comm,int); 419 EXTERN int PetscSequentialPhaseEnd(MPI_Comm,int); 420 EXTERN int PetscBarrier(PetscObject); 421 EXTERN int PetscMPIDump(FILE*); 422 423 #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE) 424 /* 425 Defines basic graphics available from PETSc. 426 */ 427 #include "petscdraw.h" 428 429 /* 430 Defines the base data structures for all PETSc objects 431 */ 432 #include "petschead.h" 433 434 /* 435 Defines PETSc profiling. 436 */ 437 #include "petsclog.h" 438 439 /* 440 For locking, unlocking and destroying AMS memories associated with 441 PETSc objects 442 */ 443 #if defined(PETSC_HAVE_AMS) 444 445 extern PetscTruth PetscAMSPublishAll; 446 #define PetscPublishAll(v) (PetscAMSPublishAll ? PetscObjectPublish((PetscObject)v) : 0) 447 #define PetscObjectTakeAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_take_access(((PetscObject)(obj))->amem)) 448 #define PetscObjectGrantAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_grant_access(((PetscObject)(obj))->amem)) 449 #define PetscObjectDepublish(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_destroy(((PetscObject)(obj))->amem)); \ 450 ((PetscObject)(obj))->amem = -1; 451 452 #else 453 454 #define PetscPublishAll(v) 0 455 #define PetscObjectTakeAccess(obj) 0 456 #define PetscObjectGrantAccess(obj) 0 457 #define PetscObjectDepublish(obj) 0 458 459 #endif 460 461 462 463 /* 464 This code allows one to pass a MPI communicator between 465 C and Fortran. MPI 2.0 defines a standard API for doing this. 466 The code here is provided to allow PETSc to work with MPI 1.1 467 standard MPI libraries. 468 */ 469 EXTERN int MPICCommToFortranComm(MPI_Comm,int *); 470 EXTERN int MPIFortranCommToCComm(int,MPI_Comm*); 471 472 /* 473 Simple PETSc parallel IO for ASCII printing 474 */ 475 EXTERN int PetscFixFilename(const char[],char[]); 476 EXTERN int PetscFOpen(MPI_Comm,const char[],const char[],FILE**); 477 EXTERN int PetscFClose(MPI_Comm,FILE*); 478 EXTERN int PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 479 EXTERN int PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 480 EXTERN int (*PetscErrorPrintf)(const char[],...); 481 EXTERN int (*PetscHelpPrintf)(MPI_Comm,const char[],...); 482 EXTERN int PetscPOpen(MPI_Comm,char *,char*,const char[],FILE **); 483 EXTERN int PetscPClose(MPI_Comm,FILE*); 484 EXTERN int PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 485 EXTERN int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 486 EXTERN int PetscSynchronizedFlush(MPI_Comm); 487 EXTERN int PetscSynchronizedFGets(MPI_Comm,FILE*,int,char[]); 488 EXTERN int PetscStartMatlab(MPI_Comm,char *,char*,FILE**); 489 EXTERN int PetscStartJava(MPI_Comm,char *,char*,FILE**); 490 EXTERN int PetscGetPetscDir(char**); 491 492 EXTERN int PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*); 493 /*S 494 PetscObjectContainer - Simple PETSc object that contains a pointer to any required data 495 496 Level: advanced 497 498 .seealso: PetscObject, PetscObjectContainerCreate() 499 S*/ 500 typedef struct _p_PetscObjectContainer* PetscObjectContainer; 501 EXTERN int PetscObjectContainerGetPointer(PetscObjectContainer,void **); 502 EXTERN int PetscObjectContainerSetPointer(PetscObjectContainer,void *); 503 EXTERN int PetscObjectContainerDestroy(PetscObjectContainer); 504 EXTERN int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *); 505 506 /* 507 For incremental debugging 508 */ 509 extern PetscTruth PetscCompare; 510 EXTERN int PetscCompareDouble(double); 511 EXTERN int PetscCompareScalar(PetscScalar); 512 EXTERN int PetscCompareInt(int); 513 514 /* 515 For use in debuggers 516 */ 517 extern int PetscGlobalRank,PetscGlobalSize; 518 EXTERN int PetscIntView(int,int[],PetscViewer); 519 EXTERN int PetscRealView(int,PetscReal[],PetscViewer); 520 EXTERN int PetscScalarView(int,PetscScalar[],PetscViewer); 521 522 /* 523 Allows accessing Matlab Engine 524 */ 525 #include "petscengine.h" 526 527 /* 528 C code optimization is often enhanced by telling the compiler 529 that certain pointer arguments to functions are not aliased to 530 to other arguments. This is not yet ANSI C standard so we define 531 the macro "restrict" to indicate that the variable is not aliased 532 to any other argument. 533 */ 534 #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus) 535 #define restrict _Restrict 536 #else 537 #if defined(restrict) 538 #undef restrict 539 #endif 540 #define restrict 541 #endif 542 543 /* 544 Determine if some of the kernel computation routines use 545 Fortran (rather than C) for the numerical calculations. On some machines 546 and compilers (like complex numbers) the Fortran version of the routines 547 is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS 548 would be set in the petscconf.h file 549 */ 550 #if defined(PETSC_USE_FORTRAN_KERNELS) 551 552 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 553 #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 554 #endif 555 556 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 557 #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 558 #endif 559 560 #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM) 561 #define PETSC_USE_FORTRAN_KERNEL_NORM 562 #endif 563 564 #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 565 #define PETSC_USE_FORTRAN_KERNEL_MAXPY 566 #endif 567 568 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 569 #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 570 #endif 571 572 #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 573 #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 574 #endif 575 576 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 577 #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 578 #endif 579 580 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 581 #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 582 #endif 583 584 #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 585 #define PETSC_USE_FORTRAN_KERNEL_MDOT 586 #endif 587 588 #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 589 #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 590 #endif 591 592 #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX) 593 #define PETSC_USE_FORTRAN_KERNEL_AYPX 594 #endif 595 596 #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY) 597 #define PETSC_USE_FORTRAN_KERNEL_WAXPY 598 #endif 599 600 #endif 601 602 /* 603 Macros for indicating code that should be compiled with a C interface, 604 rather than a C++ interface. Any routines that are dynamically loaded 605 (such as the PCCreate_XXX() routines) must be wrapped so that the name 606 mangler does not change the functions symbol name. This just hides the 607 ugly extern "C" {} wrappers. 608 */ 609 #if defined(__cplusplus) 610 #define EXTERN_C_BEGIN extern "C" { 611 #define EXTERN_C_END } 612 #else 613 #define EXTERN_C_BEGIN 614 #define EXTERN_C_END 615 #endif 616 617 /* --------------------------------------------------------------------*/ 618 619 /*M 620 size - integer variable used to contain the number of processors in 621 the relevent MPI_Comm 622 623 Level: beginner 624 625 .seealso: rank, comm 626 M*/ 627 628 /*M 629 rank - integer variable used to contain the number of this processor relative 630 to all in the relevent MPI_Comm 631 632 Level: beginner 633 634 .seealso: size, comm 635 M*/ 636 637 /*M 638 comm - MPI_Comm used in the current routine or object 639 640 Level: beginner 641 642 .seealso: size, rank 643 M*/ 644 645 /*M 646 PetscScalar - PETSc type that represents either a double precision real number or 647 a double precision complex number if the code is compiled with BOPT=g_complex or O_complex 648 649 Level: beginner 650 651 M*/ 652 653 /* 654 The IBM include files define hz, here we hide it so that it may be used 655 as a regular user variable. 656 */ 657 #if defined(hz) 658 #undef hz 659 #endif 660 661 /* For arrays that contain filenames or paths */ 662 663 #if defined(PETSC_HAVE_LIMITS_H) 664 #include <limits.h> 665 #endif 666 #if defined(PETSC_HAVE_SYS_PARAM_H) 667 #include <sys/param.h> 668 #endif 669 670 #if defined(MAXPATHLEN) 671 # define PETSC_MAX_PATH_LEN MAXPATHLEN 672 #elif defined(MAX_PATH) 673 # define PETSC_MAX_PATH_LEN MAX_PATH 674 #elif defined(_MAX_PATH) 675 # define PETSC_MAX_PATH_LEN _MAX_PATH 676 #else 677 # define PETSC_MAX_PATH_LEN 4096 678 #endif 679 680 #endif 681 682 683