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 This facilitates using C version of PETSc from C++ 11 */ 12 13 #if defined(PETSC_USE_EXTERN_CXX) && defined(__cplusplus) 14 #define PETSC_EXTERN_CXX_BEGIN extern "C" { 15 #define PETSC_EXTERN_CXX_END extern } 16 #else 17 #define PETSC_EXTERN_CXX_BEGIN 18 #define PETSC_EXTERN_CXX_END 19 #endif 20 PETSC_EXTERN_CXX_BEGIN 21 /* ========================================================================== */ 22 /* 23 Current PETSc version number and release date 24 */ 25 #include "petscversion.h" 26 27 /* ========================================================================== */ 28 /* 29 petscconf.h is contained in bmake/${PETSC_ARCH}/petscconf.h it is 30 found automatically by the compiler due to the -I${PETSC_DIR}/bmake/${PETSC_ARCH} 31 in the bmake/common_variables definition of PETSC_INCLUDE 32 */ 33 #include "petscconf.h" 34 /* 35 Fixes for configure time choices which impact our interface. Currently only 36 calling conventions and extra compiler checking falls under this category. 37 */ 38 #if !defined(PETSC_PRINTF_FORMAT_CHECK) 39 #define PETSC_PRINTF_FORMAT_CHECK(a,b) 40 #endif 41 #if !defined (PETSC_STDCALL) 42 #define PETSC_STDCALL 43 #endif 44 #if !defined (PETSC_TEMPLATE) 45 #define PETSC_TEMPLATE 46 #endif 47 48 /* ========================================================================== */ 49 50 #include <stdio.h> 51 /* 52 Defines the interface to MPI allowing the use of all MPI functions. 53 */ 54 #include "mpi.h" 55 56 /* 57 EXTERN indicates a PETSc function defined elsewhere 58 */ 59 #if !defined(EXTERN) 60 #define EXTERN extern 61 #endif 62 63 /* 64 Defines some elementary mathematics functions and constants. 65 */ 66 #include "petscmath.h" 67 68 /* 69 Basic PETSc constants 70 */ 71 72 /*E 73 PetscTruth - Logical variable. Actually an integer 74 75 Level: beginner 76 77 E*/ 78 typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth; 79 80 /*M 81 PETSC_NULL - standard way of passing in a null or array or pointer 82 83 Level: beginner 84 85 Notes: accepted by many PETSc functions to not set a parameter and instead use 86 some default 87 88 This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER, 89 PETSC_NULL_DOUBLE_PRECISION etc 90 91 .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE 92 93 M*/ 94 #define PETSC_NULL 0 95 96 /*M 97 PETSC_DECIDE - standard way of passing in integer or floating point parameter 98 where you wish PETSc to use the default. 99 100 Level: beginner 101 102 .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE 103 104 M*/ 105 #define PETSC_DECIDE -1 106 107 /*M 108 PETSC_DEFAULT - standard way of passing in integer or floating point parameter 109 where you wish PETSc to use the default. 110 111 Level: beginner 112 113 .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE 114 115 M*/ 116 #define PETSC_DEFAULT -2 117 118 #define PETSC_YES PETSC_TRUE 119 #define PETSC_NO PETSC_FALSE 120 121 /*M 122 PETSC_IGNORE - same as PETSC_NULL, means PETSc will ignore this argument 123 124 Level: beginner 125 126 Notes: accepted by many PETSc functions to not set a parameter and instead use 127 some default 128 129 This macro does not exist in Fortran; you must use PETSC_NULL_INTEGER, 130 PETSC_NULL_DOUBLE_PRECISION etc 131 132 .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_NULL, PETSC_DETERMINE 133 134 M*/ 135 #define PETSC_IGNORE PETSC_NULL 136 137 /*M 138 PETSC_DETERMINE - standard way of passing in integer or floating point parameter 139 where you wish PETSc to compute the required value. 140 141 Level: beginner 142 143 .seealso: PETSC_DECIDE, PETSC_DEFAULT, PETSC_IGNORE, PETSC_DETERMINE, VecSetSizes() 144 145 M*/ 146 #define PETSC_DETERMINE PETSC_DECIDE 147 148 /*M 149 PETSC_COMM_WORLD - a duplicate of the MPI_COMM_WORLD communicator which represents 150 all the processs 151 152 Level: beginner 153 154 Notes: PETSC_COMM_WORLD and MPI_COMM_WORLD are equivalent except that passint MPI_COMM_WORLD 155 into PETSc object constructors will result in using more MPI resources since an MPI_Comm_dup() 156 will be done on it internally. We recommend always using PETSC_COMM_WORLD 157 158 .seealso: PETSC_COMM_SELF 159 160 M*/ 161 extern MPI_Comm PETSC_COMM_WORLD; 162 163 /*M 164 PETSC_COMM_SELF - a duplicate of the MPI_COMM_SELF communicator which represents 165 the current process 166 167 Level: beginner 168 169 Notes: PETSC_COMM_SELF and MPI_COMM_SELF are equivalent except that passint MPI_COMM_SELF 170 into PETSc object constructors will result in using more MPI resources since an MPI_Comm_dup() 171 will be done on it internally. We recommend always using PETSC_COMM_SELF 172 173 .seealso: PETSC_COMM_WORLD 174 175 M*/ 176 extern MPI_Comm PETSC_COMM_SELF; 177 178 extern PetscTruth PetscInitializeCalled; 179 EXTERN int PetscSetCommWorld(MPI_Comm); 180 EXTERN int PetscSetHelpVersionFunctions(int (*)(MPI_Comm),int (*)(MPI_Comm)); 181 182 /*MC 183 PetscMalloc - Allocates memory 184 185 Input Parameter: 186 . m - number of bytes to allocate 187 188 Output Parameter: 189 . result - memory allocated 190 191 Synopsis: 192 int PetscMalloc(size_t m,void **result) 193 194 Level: beginner 195 196 Notes: Memory is always allocated at least double aligned 197 198 .seealso: PetscFree(), PetscNew() 199 200 Concepts: memory allocation 201 202 M*/ 203 #define PetscMalloc(a,b) (*PetscTrMalloc)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__,(void**)(b)) 204 /*MC 205 PetscNew - Allocates memory of a particular type 206 207 Input Parameter: 208 . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated 209 210 Output Parameter: 211 . result - memory allocated 212 213 Synopsis: 214 int PetscNew(struct type,((type *))result) 215 216 Level: beginner 217 218 .seealso: PetscFree(), PetscMalloc() 219 220 Concepts: memory allocation 221 222 M*/ 223 #define PetscNew(A,b) PetscMalloc(sizeof(A),(b)) 224 /*MC 225 PetscFree - Frees memory 226 227 Input Parameter: 228 . memory - memory to free 229 230 Synopsis: 231 int PetscFree(void *memory) 232 233 Level: beginner 234 235 Notes: Memory must have been obtained with PetscNew() or PetscMalloc() 236 237 .seealso: PetscNew(), PetscMalloc() 238 239 Concepts: memory allocation 240 241 M*/ 242 #define PetscFree(a) (*PetscTrFree)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__) 243 EXTERN int (*PetscTrMalloc)(size_t,int,char*,char*,char*,void**); 244 EXTERN int (*PetscTrFree)(void *,int,char*,char*,char*); 245 EXTERN int PetscSetMalloc(int (*)(size_t,int,char*,char*,char*,void**),int (*)(void *,int,char*,char*,char*)); 246 EXTERN int PetscClearMalloc(void); 247 248 /* 249 Routines for tracing memory corruption/bleeding with default PETSc 250 memory allocation 251 */ 252 EXTERN int PetscTrDump(FILE *); 253 EXTERN int PetscTrSpace(PetscLogDouble *,PetscLogDouble *,PetscLogDouble *); 254 EXTERN int PetscTrValid(int,const char[],const char[],const char[]); 255 EXTERN int PetscTrDebugLevel(int); 256 EXTERN int PetscTrLog(void); 257 EXTERN int PetscTrLogDump(FILE *); 258 EXTERN int PetscGetResidentSetSize(PetscLogDouble *); 259 260 /* 261 Variable type where we stash PETSc object pointers in Fortran. 262 Assumes that sizeof(long) == sizeof(void*)which is true on 263 all machines that we know. 264 */ 265 #define PetscFortranAddr long 266 267 /*E 268 PetscDataType - Used for handling different basic data types. 269 270 Level: beginner 271 272 .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(), 273 PetscDataTypeGetSize(), PetscDataTypeGetName() 274 275 E*/ 276 typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2, 277 PETSC_LONG =3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5, 278 PETSC_CHAR = 6,PETSC_LOGICAL = 7} PetscDataType; 279 #if defined(PETSC_USE_COMPLEX) 280 #define PETSC_SCALAR PETSC_COMPLEX 281 #else 282 #if defined(PETSC_USE_SINGLE) 283 #define PETSC_SCALAR PETSC_FLOAT 284 #else 285 #define PETSC_SCALAR PETSC_DOUBLE 286 #endif 287 #endif 288 #if defined(PETSC_USE_SINGLE) 289 #define PETSC_REAL PETSC_FLOAT 290 #else 291 #define PETSC_REAL PETSC_DOUBLE 292 #endif 293 #define PETSC_FORTRANADDR PETSC_LONG 294 295 EXTERN int PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*); 296 EXTERN int PetscDataTypeGetSize(PetscDataType,int*); 297 EXTERN int PetscDataTypeGetName(PetscDataType,char*[]); 298 299 /* 300 Basic memory and string operations. These are usually simple wrappers 301 around the basic Unix system calls, but a few of them have additional 302 functionality and/or error checking. 303 */ 304 EXTERN int PetscMemcpy(void *,const void *,int); 305 EXTERN int PetscBitMemcpy(void*,int,const void*,int,int,PetscDataType); 306 EXTERN int PetscMemmove(void *,void *,int); 307 EXTERN int PetscMemzero(void *,int); 308 EXTERN int PetscMemcmp(const void*,const void*,int,PetscTruth *); 309 EXTERN int PetscStrlen(const char[],int*); 310 EXTERN int PetscStrcmp(const char[],const char[],PetscTruth *); 311 EXTERN int PetscStrgrt(const char[],const char[],PetscTruth *); 312 EXTERN int PetscStrcasecmp(const char[],const char[],PetscTruth*); 313 EXTERN int PetscStrncmp(const char[],const char[],int,PetscTruth*); 314 EXTERN int PetscStrcpy(char[],const char[]); 315 EXTERN int PetscStrcat(char[],const char[]); 316 EXTERN int PetscStrncat(char[],const char[],int); 317 EXTERN int PetscStrncpy(char[],const char[],int); 318 EXTERN int PetscStrchr(const char[],char,char **); 319 EXTERN int PetscStrtolower(char[]); 320 EXTERN int PetscStrrchr(const char[],char,char **); 321 EXTERN int PetscStrstr(const char[],const char[],char **); 322 EXTERN int PetscStrallocpy(const char[],char **); 323 EXTERN int PetscStrreplace(MPI_Comm,const char[],char*,int); 324 #define PetscStrfree(a) ((a) ? PetscFree(a) : 0) 325 typedef struct {char token;char *array;char *current;} PetscToken; 326 EXTERN int PetscTokenCreate(const char[],const char,PetscToken**); 327 EXTERN int PetscTokenFind(PetscToken*,char **); 328 EXTERN int PetscTokenDestroy(PetscToken*); 329 330 /* 331 These are MPI operations for MPI_Allreduce() etc 332 */ 333 EXTERN MPI_Op PetscMaxSum_Op; 334 #if defined(PETSC_USE_COMPLEX) 335 EXTERN MPI_Op PetscSum_Op; 336 #else 337 #define PetscSum_Op MPI_SUM 338 #endif 339 EXTERN int PetscMaxSum(MPI_Comm,const int[],int*,int*); 340 341 /*S 342 PetscObject - any PETSc object, PetscViewer, Mat, Vec, SLES etc 343 344 Level: beginner 345 346 .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName() 347 S*/ 348 typedef struct _p_PetscObject* PetscObject; 349 350 /*S 351 PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed 352 by string name 353 354 Level: advanced 355 356 .seealso: PetscFListAdd(), PetscFListDestroy() 357 S*/ 358 typedef struct _PetscFList *PetscFList; 359 360 #include "petscviewer.h" 361 #include "petscoptions.h" 362 363 EXTERN int PetscShowMemoryUsage(PetscViewer,char*); 364 EXTERN int PetscGetTime(PetscLogDouble*); 365 EXTERN int PetscGetCPUTime(PetscLogDouble*); 366 EXTERN int PetscSleep(int); 367 368 /* 369 Initialization of PETSc 370 */ 371 EXTERN int PetscInitialize(int*,char***,char[],const char[]); 372 EXTERN int PetscInitializeNoArguments(void); 373 EXTERN int PetscFinalize(void); 374 EXTERN int PetscInitializeFortran(void); 375 EXTERN int PetscGetArgs(int*,char ***); 376 EXTERN int PetscEnd(void); 377 378 /* 379 ParameterDict is an abstraction for arguments to interface mechanisms 380 */ 381 extern int DICT_COOKIE; 382 typedef struct _p_Dict *ParameterDict; 383 384 typedef void (**PetscVoidFunction)(void); 385 386 /* 387 PetscTryMethod - Queries an object for a method, if it exists then calls it. 388 Can support argument checking 389 */ 390 #if defined(PETSC_FORTRAN_STUBS) 391 #define PetscTryMethod(obj,A,B,C) \ 392 0;{ int (*f)B; \ 393 *ierr = PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);if (*ierr) return; \ 394 if (f) {*ierr = (*f)C;if (*ierr) return;}\ 395 } 396 #else 397 #define PetscTryMethod(obj,A,B,C) \ 398 0;{ int (*f)B, __ierr; \ 399 __ierr = PetscObjectQueryFunction((PetscObject)obj,#A,(PetscVoidFunction)&f);CHKERRQ(__ierr); \ 400 if (f) {__ierr = (*f)C;CHKERRQ(__ierr);}\ 401 } 402 #endif 403 404 /* 405 Functions that can act on any PETSc object. 406 */ 407 EXTERN int PetscObjectDestroy(PetscObject); 408 EXTERN int PetscObjectExists(PetscObject,PetscTruth*); 409 EXTERN int PetscObjectGetComm(PetscObject,MPI_Comm *); 410 EXTERN int PetscObjectGetCookie(PetscObject,int *); 411 EXTERN int PetscObjectGetType(PetscObject,int *); 412 EXTERN int PetscObjectSetName(PetscObject,const char[]); 413 EXTERN int PetscObjectGetName(PetscObject,char*[]); 414 EXTERN int PetscObjectReference(PetscObject); 415 EXTERN int PetscObjectGetReference(PetscObject,int*); 416 EXTERN int PetscObjectDereference(PetscObject); 417 EXTERN int PetscObjectGetNewTag(PetscObject,int *); 418 EXTERN int PetscObjectSetParameterDict(PetscObject,ParameterDict); 419 EXTERN int PetscObjectGetParameterDict(PetscObject,ParameterDict*); 420 EXTERN int PetscCommGetNewTag(MPI_Comm,int *); 421 EXTERN int PetscObjectView(PetscObject,PetscViewer); 422 EXTERN int PetscObjectCompose(PetscObject,const char[],PetscObject); 423 EXTERN int PetscObjectQuery(PetscObject,const char[],PetscObject *); 424 EXTERN int PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)(void)); 425 426 /*MC 427 PetscObjectComposeFunctionDynamic - Associates a function with a given PETSc object. 428 429 Collective on PetscObject 430 431 Input Parameters: 432 + obj - the PETSc object; this must be cast with a (PetscObject), for example, 433 PetscObjectCompose((PetscObject)mat,...); 434 . name - name associated with the child function 435 . fname - name of the function 436 - ptr - function pointer (or PETSC_NULL if using dynamic libraries) 437 438 Level: advanced 439 440 Synopsis: 441 int PetscObjectComposeFunctionDynamic(PetscObject obj,char *name,char *fname,void *ptr) 442 443 Notes: 444 PetscObjectComposeFunctionDynamic() can be used with any PETSc object (such as 445 Mat, Vec, KSP, SNES, etc.) or any user-provided object. 446 447 The composed function must be wrapped in a EXTERN_C_BEGIN/END for this to 448 work in C++/complex with dynamic link libraries (PETSC_USE_DYNAMIC_LIBRARIES) 449 enabled. 450 451 Concepts: objects^composing functions 452 Concepts: composing functions 453 Concepts: functions^querying 454 Concepts: objects^querying 455 Concepts: querying objects 456 457 .seealso: PetscObjectQueryFunction() 458 M*/ 459 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 460 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0) 461 #else 462 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(void (*)(void))(d)) 463 #endif 464 465 EXTERN int PetscObjectQueryFunction(PetscObject,const char[],void (**)(void)); 466 EXTERN int PetscObjectSetOptionsPrefix(PetscObject,const char[]); 467 EXTERN int PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 468 EXTERN int PetscObjectPrependOptionsPrefix(PetscObject,const char[]); 469 EXTERN int PetscObjectGetOptionsPrefix(PetscObject,char*[]); 470 EXTERN int PetscObjectPublish(PetscObject); 471 EXTERN int PetscObjectChangeTypeName(PetscObject,char *); 472 EXTERN int PetscObjectChangeSerializeName(PetscObject,char *); 473 EXTERN int PetscObjectRegisterDestroy(PetscObject); 474 EXTERN int PetscObjectRegisterDestroyAll(void); 475 EXTERN int PetscObjectName(PetscObject); 476 EXTERN int PetscTypeCompare(PetscObject,char*,PetscTruth*); 477 EXTERN int PetscSerializeCompare(PetscObject,char*,PetscTruth*); 478 479 /* 480 Defines PETSc error handling. 481 */ 482 #include "petscerror.h" 483 484 /*S 485 PetscOList - Linked list of PETSc objects, accessable by string name 486 487 Level: advanced 488 489 .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind() 490 S*/ 491 typedef struct _PetscOList *PetscOList; 492 493 EXTERN int PetscOListDestroy(PetscOList *); 494 EXTERN int PetscOListFind(PetscOList,const char[],PetscObject*); 495 EXTERN int PetscOListReverseFind(PetscOList,PetscObject,char**); 496 EXTERN int PetscOListAdd(PetscOList *,const char[],PetscObject); 497 EXTERN int PetscOListDuplicate(PetscOList,PetscOList *); 498 499 /* 500 Dynamic library lists. Lists of names of routines in dynamic 501 link libraries that will be loaded as needed. 502 */ 503 EXTERN int PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void)); 504 EXTERN int PetscFListDestroy(PetscFList*); 505 EXTERN int PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)(void)); 506 EXTERN int PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],char *,char *,PetscFList); 507 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 508 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0) 509 #else 510 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c) 511 #endif 512 EXTERN int PetscFListDuplicate(PetscFList,PetscFList *); 513 EXTERN int PetscFListView(PetscFList,PetscViewer); 514 EXTERN int PetscFListConcat(const char [],const char [],char []); 515 EXTERN int PetscFListGet(PetscFList,char ***,int*); 516 517 /*S 518 PetscDLLibraryList - Linked list of dynamics libraries to search for functions 519 520 Level: advanced 521 522 PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries 523 524 .seealso: PetscDLLibraryOpen() 525 S*/ 526 typedef struct _PetscDLLibraryList *PetscDLLibraryList; 527 extern PetscDLLibraryList DLLibrariesLoaded; 528 EXTERN int PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *); 529 EXTERN int PetscDLLibraryOpen(MPI_Comm,const char[],void **); 530 EXTERN int PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **); 531 EXTERN int PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]); 532 EXTERN int PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]); 533 EXTERN int PetscDLLibraryClose(PetscDLLibraryList); 534 EXTERN int PetscDLLibraryPrintPath(void); 535 EXTERN int PetscDLLibraryGetInfo(void *,char *,char **); 536 537 /* 538 Mechanism for translating PETSc object representations between languages 539 Not currently used. 540 */ 541 typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage; 542 #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C 543 EXTERN int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *); 544 EXTERN int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **); 545 546 /* 547 Useful utility routines 548 */ 549 EXTERN int PetscSplitOwnership(MPI_Comm,int*,int*); 550 EXTERN int PetscSplitOwnershipBlock(MPI_Comm,int,int*,int*); 551 EXTERN int PetscSequentialPhaseBegin(MPI_Comm,int); 552 EXTERN int PetscSequentialPhaseEnd(MPI_Comm,int); 553 EXTERN int PetscBarrier(PetscObject); 554 EXTERN int PetscMPIDump(FILE*); 555 556 #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE) 557 /* 558 Defines basic graphics available from PETSc. 559 */ 560 #include "petscdraw.h" 561 562 /* 563 Defines the base data structures for all PETSc objects 564 */ 565 #include "petschead.h" 566 567 /* 568 Defines PETSc profiling. 569 */ 570 #include "petsclog.h" 571 572 /* 573 For locking, unlocking and destroying AMS memories associated with 574 PETSc objects 575 */ 576 #if defined(PETSC_HAVE_AMS) 577 578 extern PetscTruth PetscAMSPublishAll; 579 #define PetscPublishAll(v) (PetscAMSPublishAll ? PetscObjectPublish((PetscObject)v) : 0) 580 #define PetscObjectTakeAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_take_access(((PetscObject)(obj))->amem)) 581 #define PetscObjectGrantAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_grant_access(((PetscObject)(obj))->amem)) 582 #define PetscObjectDepublish(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_destroy(((PetscObject)(obj))->amem)); \ 583 ((PetscObject)(obj))->amem = -1; 584 585 #else 586 587 #define PetscPublishAll(v) 0 588 #define PetscObjectTakeAccess(obj) 0 589 #define PetscObjectGrantAccess(obj) 0 590 #define PetscObjectDepublish(obj) 0 591 592 #endif 593 594 595 596 /* 597 This code allows one to pass a MPI communicator between 598 C and Fortran. MPI 2.0 defines a standard API for doing this. 599 The code here is provided to allow PETSc to work with MPI 1.1 600 standard MPI libraries. 601 */ 602 EXTERN int MPICCommToFortranComm(MPI_Comm,int *); 603 EXTERN int MPIFortranCommToCComm(int,MPI_Comm*); 604 605 /* 606 Simple PETSc parallel IO for ASCII printing 607 */ 608 EXTERN int PetscFixFilename(const char[],char[]); 609 EXTERN int PetscFOpen(MPI_Comm,const char[],const char[],FILE**); 610 EXTERN int PetscFClose(MPI_Comm,FILE*); 611 EXTERN int PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 612 EXTERN int PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 613 614 /*MC 615 PetscErrorPrintf - Prints error messages. 616 617 Not Collective 618 619 Synopsis: 620 int (*PetscErrorPrintf)(const char format[],...); 621 622 Input Parameters: 623 . format - the usual printf() format string 624 625 Options Database Keys: 626 . -error_output_stderr - cause error messages to be printed to stderr instead of the 627 (default) stdout 628 629 630 Level: developer 631 632 Fortran Note: 633 This routine is not supported in Fortran. 634 635 Concepts: error messages^printing 636 Concepts: printing^error messages 637 638 .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscHelpPrintf() 639 M*/ 640 EXTERN int (*PetscErrorPrintf)(const char[],...); 641 642 /*MC 643 PetscHelpPrintf - Prints help messages. 644 645 Not Collective 646 647 Synopsis: 648 int (*PetscHelpPrintf)(const char format[],...); 649 650 Input Parameters: 651 . format - the usual printf() format string 652 653 Level: developer 654 655 Fortran Note: 656 This routine is not supported in Fortran. 657 658 Concepts: help messages^printing 659 Concepts: printing^help messages 660 661 .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscErrorPrintf() 662 M*/ 663 EXTERN int (*PetscHelpPrintf)(MPI_Comm,const char[],...); 664 665 EXTERN int PetscPOpen(MPI_Comm,char *,char*,const char[],FILE **); 666 EXTERN int PetscPClose(MPI_Comm,FILE*); 667 EXTERN int PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 668 EXTERN int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 669 EXTERN int PetscSynchronizedFlush(MPI_Comm); 670 EXTERN int PetscSynchronizedFGets(MPI_Comm,FILE*,int,char[]); 671 EXTERN int PetscStartMatlab(MPI_Comm,char *,char*,FILE**); 672 EXTERN int PetscStartJava(MPI_Comm,char *,char*,FILE**); 673 EXTERN int PetscGetPetscDir(char**); 674 675 EXTERN int PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*); 676 /*S 677 PetscObjectContainer - Simple PETSc object that contains a pointer to any required data 678 679 Level: advanced 680 681 .seealso: PetscObject, PetscObjectContainerCreate() 682 S*/ 683 typedef struct _p_PetscObjectContainer* PetscObjectContainer; 684 EXTERN int PetscObjectContainerGetPointer(PetscObjectContainer,void **); 685 EXTERN int PetscObjectContainerSetPointer(PetscObjectContainer,void *); 686 EXTERN int PetscObjectContainerDestroy(PetscObjectContainer); 687 EXTERN int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *); 688 689 /* 690 For incremental debugging 691 */ 692 extern PetscTruth PetscCompare; 693 EXTERN int PetscCompareDouble(double); 694 EXTERN int PetscCompareScalar(PetscScalar); 695 EXTERN int PetscCompareInt(int); 696 697 /* 698 For use in debuggers 699 */ 700 extern int PetscGlobalRank,PetscGlobalSize; 701 EXTERN int PetscIntView(int,int[],PetscViewer); 702 EXTERN int PetscRealView(int,PetscReal[],PetscViewer); 703 EXTERN int PetscScalarView(int,PetscScalar[],PetscViewer); 704 705 /* 706 Allows accessing Matlab Engine 707 */ 708 #include "petscengine.h" 709 710 /* 711 C code optimization is often enhanced by telling the compiler 712 that certain pointer arguments to functions are not aliased to 713 to other arguments. This is not yet ANSI C standard so we define 714 the macro "restrict" to indicate that the variable is not aliased 715 to any other argument. 716 */ 717 #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus) 718 #define restrict _Restrict 719 #else 720 #if defined(restrict) 721 #undef restrict 722 #endif 723 #define restrict 724 #endif 725 726 /* 727 Determine if some of the kernel computation routines use 728 Fortran (rather than C) for the numerical calculations. On some machines 729 and compilers (like complex numbers) the Fortran version of the routines 730 is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS 731 would be set in the petscconf.h file 732 */ 733 #if defined(PETSC_USE_FORTRAN_KERNELS) 734 735 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 736 #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 737 #endif 738 739 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 740 #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 741 #endif 742 743 #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM) 744 #define PETSC_USE_FORTRAN_KERNEL_NORM 745 #endif 746 747 #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 748 #define PETSC_USE_FORTRAN_KERNEL_MAXPY 749 #endif 750 751 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 752 #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 753 #endif 754 755 #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 756 #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 757 #endif 758 759 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 760 #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 761 #endif 762 763 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 764 #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 765 #endif 766 767 #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 768 #define PETSC_USE_FORTRAN_KERNEL_MDOT 769 #endif 770 771 #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 772 #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 773 #endif 774 775 #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX) 776 #define PETSC_USE_FORTRAN_KERNEL_AYPX 777 #endif 778 779 #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY) 780 #define PETSC_USE_FORTRAN_KERNEL_WAXPY 781 #endif 782 783 #endif 784 785 /* 786 Macros for indicating code that should be compiled with a C interface, 787 rather than a C++ interface. Any routines that are dynamically loaded 788 (such as the PCCreate_XXX() routines) must be wrapped so that the name 789 mangler does not change the functions symbol name. This just hides the 790 ugly extern "C" {} wrappers. 791 */ 792 #if defined(__cplusplus) 793 #define EXTERN_C_BEGIN extern "C" { 794 #define EXTERN_C_END } 795 #else 796 #define EXTERN_C_BEGIN 797 #define EXTERN_C_END 798 #endif 799 800 /* --------------------------------------------------------------------*/ 801 802 /*M 803 size - integer variable used to contain the number of processors in 804 the relevent MPI_Comm 805 806 Level: beginner 807 808 .seealso: rank, comm 809 M*/ 810 811 /*M 812 rank - integer variable used to contain the number of this processor relative 813 to all in the relevent MPI_Comm 814 815 Level: beginner 816 817 .seealso: size, comm 818 M*/ 819 820 /*M 821 comm - MPI_Comm used in the current routine or object 822 823 Level: beginner 824 825 .seealso: size, rank 826 M*/ 827 828 /*M 829 MPI_Comm - the basic object used by MPI to determine which processes are involved in a 830 communication 831 832 Level: beginner 833 834 Note: This manual page is a place-holder because MPICH does not have a manual page for MPI_Comm 835 836 .seealso: size, rank, comm, PETSC_COMM_WORLD, PETSC_COMM_SELF 837 M*/ 838 839 /*M 840 PetscScalar - PETSc type that represents either a double precision real number or 841 a double precision complex number if the code is compiled with BOPT=g_complex or O_complex 842 843 Level: beginner 844 845 .seealso: PetscReal, PassiveReal, PassiveScalar 846 M*/ 847 848 /*M 849 PetscReal - PETSc type that represents a double precision real number 850 851 Level: beginner 852 853 .seealso: PetscScalar, PassiveReal, PassiveScalar 854 M*/ 855 856 /*M 857 PassiveScalar - PETSc type that represents either a double precision real number or 858 a double precision complex number if the code is compiled with BOPT=g_complex or O_complex 859 860 Level: beginner 861 862 This is the same as a PetscScalar except in code that is automatically differentiated it is 863 treated as a constant (not an indendent or dependent variable) 864 865 .seealso: PetscReal, PassiveReal, PetscScalar 866 M*/ 867 868 /*M 869 PassiveReal - PETSc type that represents a double precision real number 870 871 Level: beginner 872 873 This is the same as a PetscReal except in code that is automatically differentiated it is 874 treated as a constant (not an indendent or dependent variable) 875 876 .seealso: PetscScalar, PetscReal, PassiveScalar 877 M*/ 878 879 /* 880 The IBM include files define hz, here we hide it so that it may be used 881 as a regular user variable. 882 */ 883 #if defined(hz) 884 #undef hz 885 #endif 886 887 /* For arrays that contain filenames or paths */ 888 889 #if defined(PETSC_HAVE_LIMITS_H) 890 #include <limits.h> 891 #endif 892 #if defined(PETSC_HAVE_SYS_PARAM_H) 893 #include <sys/param.h> 894 #endif 895 896 #if defined(MAXPATHLEN) 897 # define PETSC_MAX_PATH_LEN MAXPATHLEN 898 #elif defined(MAX_PATH) 899 # define PETSC_MAX_PATH_LEN MAX_PATH 900 #elif defined(_MAX_PATH) 901 # define PETSC_MAX_PATH_LEN _MAX_PATH 902 #else 903 # define PETSC_MAX_PATH_LEN 4096 904 #endif 905 906 PETSC_EXTERN_CXX_END 907 #endif 908 909 910