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