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