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 328 /*MC 329 PetscObjectComposeFunctionDynamic - Associates a function with a given PETSc object. 330 331 Collective on PetscObject 332 333 Input Parameters: 334 + obj - the PETSc object; this must be cast with a (PetscObject), for example, 335 PetscObjectCompose((PetscObject)mat,...); 336 . name - name associated with the child function 337 . fname - name of the function 338 - ptr - function pointer (or PETSC_NULL if using dynamic libraries) 339 340 Level: advanced 341 342 Synopsis: 343 int PetscObjectComposeFunctionDynamic(PetscObject obj,char *name,char *fname,void *ptr) 344 345 Notes: 346 PetscObjectComposeFunctionDynamic() can be used with any PETSc object (such as 347 Mat, Vec, KSP, SNES, etc.) or any user-provided object. 348 349 The composed function must be wrapped in a EXTERN_C_BEGIN/END for this to 350 work in C++/complex with dynamic link libraries (PETSC_USE_DYNAMIC_LIBRARIES) 351 enabled. 352 353 Concepts: objects^composing functions 354 Concepts: composing functions 355 Concepts: functions^querying 356 Concepts: objects^querying 357 Concepts: querying objects 358 359 .seealso: PetscObjectQueryFunction() 360 M*/ 361 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 362 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0) 363 #else 364 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(void (*)(void))(d)) 365 #endif 366 367 EXTERN int PetscObjectQueryFunction(PetscObject,const char[],void (**)(void)); 368 EXTERN int PetscObjectSetOptionsPrefix(PetscObject,const char[]); 369 EXTERN int PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 370 EXTERN int PetscObjectPrependOptionsPrefix(PetscObject,const char[]); 371 EXTERN int PetscObjectGetOptionsPrefix(PetscObject,char*[]); 372 EXTERN int PetscObjectPublish(PetscObject); 373 EXTERN int PetscObjectChangeTypeName(PetscObject,char *); 374 EXTERN int PetscObjectChangeSerializeName(PetscObject,char *); 375 EXTERN int PetscObjectRegisterDestroy(PetscObject); 376 EXTERN int PetscObjectRegisterDestroyAll(void); 377 EXTERN int PetscObjectName(PetscObject); 378 EXTERN int PetscTypeCompare(PetscObject,char*,PetscTruth*); 379 EXTERN int PetscSerializeCompare(PetscObject,char*,PetscTruth*); 380 381 /* 382 Defines PETSc error handling. 383 */ 384 #include "petscerror.h" 385 386 /*S 387 PetscOList - Linked list of PETSc objects, accessable by string name 388 389 Level: advanced 390 391 .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind() 392 S*/ 393 typedef struct _PetscOList *PetscOList; 394 395 EXTERN int PetscOListDestroy(PetscOList *); 396 EXTERN int PetscOListFind(PetscOList,const char[],PetscObject*); 397 EXTERN int PetscOListReverseFind(PetscOList,PetscObject,char**); 398 EXTERN int PetscOListAdd(PetscOList *,const char[],PetscObject); 399 EXTERN int PetscOListDuplicate(PetscOList,PetscOList *); 400 401 /* 402 Dynamic library lists. Lists of names of routines in dynamic 403 link libraries that will be loaded as needed. 404 */ 405 EXTERN int PetscFListAdd(PetscFList*,const char[],const char[],void (*)(void)); 406 EXTERN int PetscFListDestroy(PetscFList*); 407 EXTERN int PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)(void)); 408 EXTERN int PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],char *,char *,PetscFList); 409 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 410 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0) 411 #else 412 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)(void))c) 413 #endif 414 EXTERN int PetscFListDuplicate(PetscFList,PetscFList *); 415 EXTERN int PetscFListView(PetscFList,PetscViewer); 416 EXTERN int PetscFListConcat(const char [],const char [],char []); 417 EXTERN int PetscFListGet(PetscFList,char ***,int*); 418 419 /*S 420 PetscDLLibraryList - Linked list of dynamics libraries to search for functions 421 422 Level: advanced 423 424 PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries 425 426 .seealso: PetscDLLibraryOpen() 427 S*/ 428 typedef struct _PetscDLLibraryList *PetscDLLibraryList; 429 extern PetscDLLibraryList DLLibrariesLoaded; 430 EXTERN int PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *); 431 EXTERN int PetscDLLibraryOpen(MPI_Comm,const char[],void **); 432 EXTERN int PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **); 433 EXTERN int PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]); 434 EXTERN int PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]); 435 EXTERN int PetscDLLibraryClose(PetscDLLibraryList); 436 EXTERN int PetscDLLibraryPrintPath(void); 437 EXTERN int PetscDLLibraryGetInfo(void *,char *,char **); 438 439 /* 440 Mechanism for translating PETSc object representations between languages 441 Not currently used. 442 */ 443 typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage; 444 #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C 445 EXTERN int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *); 446 EXTERN int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **); 447 448 /* 449 Useful utility routines 450 */ 451 EXTERN int PetscSplitOwnership(MPI_Comm,int*,int*); 452 EXTERN int PetscSplitOwnershipBlock(MPI_Comm,int,int*,int*); 453 EXTERN int PetscSequentialPhaseBegin(MPI_Comm,int); 454 EXTERN int PetscSequentialPhaseEnd(MPI_Comm,int); 455 EXTERN int PetscBarrier(PetscObject); 456 EXTERN int PetscMPIDump(FILE*); 457 458 #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE) 459 /* 460 Defines basic graphics available from PETSc. 461 */ 462 #include "petscdraw.h" 463 464 /* 465 Defines the base data structures for all PETSc objects 466 */ 467 #include "petschead.h" 468 469 /* 470 Defines PETSc profiling. 471 */ 472 #include "petsclog.h" 473 474 /* 475 For locking, unlocking and destroying AMS memories associated with 476 PETSc objects 477 */ 478 #if defined(PETSC_HAVE_AMS) 479 480 extern PetscTruth PetscAMSPublishAll; 481 #define PetscPublishAll(v) (PetscAMSPublishAll ? PetscObjectPublish((PetscObject)v) : 0) 482 #define PetscObjectTakeAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_take_access(((PetscObject)(obj))->amem)) 483 #define PetscObjectGrantAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_grant_access(((PetscObject)(obj))->amem)) 484 #define PetscObjectDepublish(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_destroy(((PetscObject)(obj))->amem)); \ 485 ((PetscObject)(obj))->amem = -1; 486 487 #else 488 489 #define PetscPublishAll(v) 0 490 #define PetscObjectTakeAccess(obj) 0 491 #define PetscObjectGrantAccess(obj) 0 492 #define PetscObjectDepublish(obj) 0 493 494 #endif 495 496 497 498 /* 499 This code allows one to pass a MPI communicator between 500 C and Fortran. MPI 2.0 defines a standard API for doing this. 501 The code here is provided to allow PETSc to work with MPI 1.1 502 standard MPI libraries. 503 */ 504 EXTERN int MPICCommToFortranComm(MPI_Comm,int *); 505 EXTERN int MPIFortranCommToCComm(int,MPI_Comm*); 506 507 /* 508 Simple PETSc parallel IO for ASCII printing 509 */ 510 EXTERN int PetscFixFilename(const char[],char[]); 511 EXTERN int PetscFOpen(MPI_Comm,const char[],const char[],FILE**); 512 EXTERN int PetscFClose(MPI_Comm,FILE*); 513 EXTERN int PetscFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 514 EXTERN int PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 515 516 /*MC 517 PetscErrorPrintf - Prints error messages. 518 519 Not Collective 520 521 Synopsis: 522 int (*PetscErrorPrintf)(const char format[],...); 523 524 Input Parameters: 525 . format - the usual printf() format string 526 527 Level: developer 528 529 Fortran Note: 530 This routine is not supported in Fortran. 531 532 Concepts: error messages^printing 533 Concepts: printing^error messages 534 535 .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscHelpPrintf() 536 M*/ 537 EXTERN int (*PetscErrorPrintf)(const char[],...); 538 539 /*MC 540 PetscHelpPrintf - Prints help messages. 541 542 Not Collective 543 544 Synopsis: 545 int (*PetscHelpPrintf)(const char format[],...); 546 547 Input Parameters: 548 . format - the usual printf() format string 549 550 Level: developer 551 552 Fortran Note: 553 This routine is not supported in Fortran. 554 555 Concepts: help messages^printing 556 Concepts: printing^help messages 557 558 .seealso: PetscFPrintf(), PetscSynchronizedPrintf(), PetscErrorPrintf() 559 M*/ 560 EXTERN int (*PetscHelpPrintf)(MPI_Comm,const char[],...); 561 562 EXTERN int PetscPOpen(MPI_Comm,char *,char*,const char[],FILE **); 563 EXTERN int PetscPClose(MPI_Comm,FILE*); 564 EXTERN int PetscSynchronizedPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 565 EXTERN int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 566 EXTERN int PetscSynchronizedFlush(MPI_Comm); 567 EXTERN int PetscSynchronizedFGets(MPI_Comm,FILE*,int,char[]); 568 EXTERN int PetscStartMatlab(MPI_Comm,char *,char*,FILE**); 569 EXTERN int PetscStartJava(MPI_Comm,char *,char*,FILE**); 570 EXTERN int PetscGetPetscDir(char**); 571 572 EXTERN int PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*); 573 /*S 574 PetscObjectContainer - Simple PETSc object that contains a pointer to any required data 575 576 Level: advanced 577 578 .seealso: PetscObject, PetscObjectContainerCreate() 579 S*/ 580 typedef struct _p_PetscObjectContainer* PetscObjectContainer; 581 EXTERN int PetscObjectContainerGetPointer(PetscObjectContainer,void **); 582 EXTERN int PetscObjectContainerSetPointer(PetscObjectContainer,void *); 583 EXTERN int PetscObjectContainerDestroy(PetscObjectContainer); 584 EXTERN int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *); 585 586 /* 587 For incremental debugging 588 */ 589 extern PetscTruth PetscCompare; 590 EXTERN int PetscCompareDouble(double); 591 EXTERN int PetscCompareScalar(PetscScalar); 592 EXTERN int PetscCompareInt(int); 593 594 /* 595 For use in debuggers 596 */ 597 extern int PetscGlobalRank,PetscGlobalSize; 598 EXTERN int PetscIntView(int,int[],PetscViewer); 599 EXTERN int PetscRealView(int,PetscReal[],PetscViewer); 600 EXTERN int PetscScalarView(int,PetscScalar[],PetscViewer); 601 602 /* 603 Allows accessing Matlab Engine 604 */ 605 #include "petscengine.h" 606 607 /* 608 C code optimization is often enhanced by telling the compiler 609 that certain pointer arguments to functions are not aliased to 610 to other arguments. This is not yet ANSI C standard so we define 611 the macro "restrict" to indicate that the variable is not aliased 612 to any other argument. 613 */ 614 #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus) 615 #define restrict _Restrict 616 #else 617 #if defined(restrict) 618 #undef restrict 619 #endif 620 #define restrict 621 #endif 622 623 /* 624 Determine if some of the kernel computation routines use 625 Fortran (rather than C) for the numerical calculations. On some machines 626 and compilers (like complex numbers) the Fortran version of the routines 627 is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS 628 would be set in the petscconf.h file 629 */ 630 #if defined(PETSC_USE_FORTRAN_KERNELS) 631 632 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 633 #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 634 #endif 635 636 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 637 #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 638 #endif 639 640 #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM) 641 #define PETSC_USE_FORTRAN_KERNEL_NORM 642 #endif 643 644 #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 645 #define PETSC_USE_FORTRAN_KERNEL_MAXPY 646 #endif 647 648 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 649 #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 650 #endif 651 652 #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 653 #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 654 #endif 655 656 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 657 #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 658 #endif 659 660 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 661 #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 662 #endif 663 664 #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 665 #define PETSC_USE_FORTRAN_KERNEL_MDOT 666 #endif 667 668 #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 669 #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 670 #endif 671 672 #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX) 673 #define PETSC_USE_FORTRAN_KERNEL_AYPX 674 #endif 675 676 #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY) 677 #define PETSC_USE_FORTRAN_KERNEL_WAXPY 678 #endif 679 680 #endif 681 682 /* 683 Macros for indicating code that should be compiled with a C interface, 684 rather than a C++ interface. Any routines that are dynamically loaded 685 (such as the PCCreate_XXX() routines) must be wrapped so that the name 686 mangler does not change the functions symbol name. This just hides the 687 ugly extern "C" {} wrappers. 688 */ 689 #if defined(__cplusplus) 690 #define EXTERN_C_BEGIN extern "C" { 691 #define EXTERN_C_END } 692 #else 693 #define EXTERN_C_BEGIN 694 #define EXTERN_C_END 695 #endif 696 697 /* --------------------------------------------------------------------*/ 698 699 /*M 700 size - integer variable used to contain the number of processors in 701 the relevent MPI_Comm 702 703 Level: beginner 704 705 .seealso: rank, comm 706 M*/ 707 708 /*M 709 rank - integer variable used to contain the number of this processor relative 710 to all in the relevent MPI_Comm 711 712 Level: beginner 713 714 .seealso: size, comm 715 M*/ 716 717 /*M 718 comm - MPI_Comm used in the current routine or object 719 720 Level: beginner 721 722 .seealso: size, rank 723 M*/ 724 725 /*M 726 MPI_Comm - the basic object used by MPI to determine which processes are involved in a 727 communication 728 729 Level: beginner 730 731 Note: This manual page is a place-holder because MPICH does not have a manual page for MPI_Comm 732 733 .seealso: size, rank, comm, PETSC_COMM_WORLD, PETSC_COMM_SELF 734 M*/ 735 736 /*M 737 PetscScalar - PETSc type that represents either a double precision real number or 738 a double precision complex number if the code is compiled with BOPT=g_complex or O_complex 739 740 Level: beginner 741 742 M*/ 743 744 /* 745 The IBM include files define hz, here we hide it so that it may be used 746 as a regular user variable. 747 */ 748 #if defined(hz) 749 #undef hz 750 #endif 751 752 /* For arrays that contain filenames or paths */ 753 754 #if defined(PETSC_HAVE_LIMITS_H) 755 #include <limits.h> 756 #endif 757 #if defined(PETSC_HAVE_SYS_PARAM_H) 758 #include <sys/param.h> 759 #endif 760 761 #if defined(MAXPATHLEN) 762 # define PETSC_MAX_PATH_LEN MAXPATHLEN 763 #elif defined(MAX_PATH) 764 # define PETSC_MAX_PATH_LEN MAX_PATH 765 #elif defined(_MAX_PATH) 766 # define PETSC_MAX_PATH_LEN _MAX_PATH 767 #else 768 # define PETSC_MAX_PATH_LEN 4096 769 #endif 770 771 #endif 772 773 774