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