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