1 /* $Id: petsc.h,v 1.297 2001/09/07 20:13:16 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(void *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 #if defined(PETSC_USE_SINGLE) 173 #define PETSC_SCALAR PETSC_FLOAT 174 #else 175 #define PETSC_SCALAR PETSC_DOUBLE 176 #endif 177 #endif 178 #if defined(PETSC_USE_SINGLE) 179 #define PETSC_REAL PETSC_FLOAT 180 #else 181 #define PETSC_REAL PETSC_DOUBLE 182 #endif 183 #define PETSC_FORTRANADDR PETSC_LONG 184 185 EXTERN int PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*); 186 EXTERN int PetscDataTypeGetSize(PetscDataType,int*); 187 EXTERN int PetscDataTypeGetName(PetscDataType,char*[]); 188 189 /* 190 Basic memory and string operations. These are usually simple wrappers 191 around the basic Unix system calls, but a few of them have additional 192 functionality and/or error checking. 193 */ 194 EXTERN int PetscMemcpy(void *,const void *,int); 195 EXTERN int PetscBitMemcpy(void*,int,const void*,int,int,PetscDataType); 196 EXTERN int PetscMemmove(void *,void *,int); 197 EXTERN int PetscMemzero(void *,int); 198 EXTERN int PetscMemcmp(const void*,const void*,int,PetscTruth *); 199 EXTERN int PetscStrlen(const char[],int*); 200 EXTERN int PetscStrcmp(const char[],const char[],PetscTruth *); 201 EXTERN int PetscStrgrt(const char[],const char[],PetscTruth *); 202 EXTERN int PetscStrcasecmp(const char[],const char[],PetscTruth*); 203 EXTERN int PetscStrncmp(const char[],const char[],int,PetscTruth*); 204 EXTERN int PetscStrcpy(char[],const char[]); 205 EXTERN int PetscStrcat(char[],const char[]); 206 EXTERN int PetscStrncat(char[],const char[],int); 207 EXTERN int PetscStrncpy(char[],const char[],int); 208 EXTERN int PetscStrchr(const char[],char,char **); 209 EXTERN int PetscStrtolower(char[]); 210 EXTERN int PetscStrrchr(const char[],char,char **); 211 EXTERN int PetscStrstr(const char[],const char[],char **); 212 EXTERN int PetscStrtok(const char[],const char[],char **); 213 EXTERN int PetscStrtok2(const char[],const char[],char **); 214 EXTERN int PetscStrallocpy(const char[],char **); 215 EXTERN int PetscStrreplace(MPI_Comm,const char[],char*,int); 216 #define PetscStrfree(a) ((a) ? PetscFree(a) : 0) 217 218 /* 219 These are MPI operations for MPI_Allreduce() etc 220 */ 221 EXTERN MPI_Op PetscMaxSum_Op; 222 #if defined(PETSC_USE_COMPLEX) 223 EXTERN MPI_Op PetscSum_Op; 224 #else 225 #define PetscSum_Op MPI_SUM 226 #endif 227 228 /* 229 Each PETSc object class has it's own cookie (internal integer in the 230 data structure used for error checking). These are all defined by an offset 231 from the lowest one, PETSC_COOKIE. 232 */ 233 #define PETSC_COOKIE 1211211 234 #define PETSC_MAX_COOKIES 60 235 #define PETSC_LARGEST_COOKIE_PREDEFINED PETSC_COOKIE + 30 236 #define PETSC_LARGEST_COOKIE_ALLOWED PETSC_COOKIE + PETSC_MAX_COOKIES 237 extern int PETSC_LARGEST_COOKIE; 238 239 /*S 240 PetscObject - any PETSc object, PetscViewer, Mat, Vec, SLES etc 241 242 Level: beginner 243 244 .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName() 245 S*/ 246 typedef struct _p_PetscObject* PetscObject; 247 248 /*S 249 PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed 250 by string name 251 252 Level: advanced 253 254 .seealso: PetscFListAdd(), PetscFListDestroy() 255 S*/ 256 typedef struct _PetscFList *PetscFList; 257 258 #include "petscviewer.h" 259 #include "petscoptions.h" 260 261 EXTERN int PetscShowMemoryUsage(PetscViewer,char*); 262 EXTERN int PetscGetTime(PetscLogDouble*); 263 EXTERN int PetscGetCPUTime(PetscLogDouble*); 264 EXTERN int PetscSleep(int); 265 266 /* 267 Initialization of PETSc 268 */ 269 EXTERN int PetscInitialize(int*,char***,char[],const char[]); 270 EXTERN int PetscInitializeNoArguments(void); 271 EXTERN int PetscFinalize(void); 272 EXTERN int PetscInitializeFortran(void); 273 EXTERN int PetscGetArgs(int*,char ***); 274 EXTERN int PetscEnd(); 275 276 /* 277 Functions that can act on any PETSc object. 278 */ 279 EXTERN int PetscObjectDestroy(PetscObject); 280 EXTERN int PetscObjectExists(PetscObject,PetscTruth*); 281 EXTERN int PetscObjectGetComm(PetscObject,MPI_Comm *); 282 EXTERN int PetscObjectGetCookie(PetscObject,int *); 283 EXTERN int PetscObjectGetType(PetscObject,int *); 284 EXTERN int PetscObjectSetName(PetscObject,const char[]); 285 EXTERN int PetscObjectGetName(PetscObject,char*[]); 286 EXTERN int PetscObjectReference(PetscObject); 287 EXTERN int PetscObjectGetReference(PetscObject,int*); 288 EXTERN int PetscObjectDereference(PetscObject); 289 EXTERN int PetscObjectGetNewTag(PetscObject,int *); 290 EXTERN int PetscCommGetNewTag(MPI_Comm,int *); 291 EXTERN int PetscObjectView(PetscObject,PetscViewer); 292 EXTERN int PetscObjectCompose(PetscObject,const char[],PetscObject); 293 EXTERN int PetscObjectQuery(PetscObject,const char[],PetscObject *); 294 EXTERN int PetscObjectComposeFunction(PetscObject,const char[],const char[],void (*)()); 295 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 296 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,0) 297 #else 298 #define PetscObjectComposeFunctionDynamic(a,b,c,d) PetscObjectComposeFunction(a,b,c,(void (*)())(d)) 299 #endif 300 EXTERN int PetscObjectQueryFunction(PetscObject,const char[],void (**)()); 301 EXTERN int PetscObjectSetOptionsPrefix(PetscObject,const char[]); 302 EXTERN int PetscObjectAppendOptionsPrefix(PetscObject,const char[]); 303 EXTERN int PetscObjectPrependOptionsPrefix(PetscObject,const char[]); 304 EXTERN int PetscObjectGetOptionsPrefix(PetscObject,char*[]); 305 EXTERN int PetscObjectPublish(PetscObject); 306 EXTERN int PetscObjectChangeTypeName(PetscObject,char *); 307 EXTERN int PetscObjectRegisterDestroy(PetscObject); 308 EXTERN int PetscObjectRegisterDestroyAll(void); 309 EXTERN int PetscObjectName(PetscObject); 310 EXTERN int PetscTypeCompare(PetscObject,char*,PetscTruth*); 311 312 /* 313 Defines PETSc error handling. 314 */ 315 #include "petscerror.h" 316 317 /*S 318 PetscOList - Linked list of PETSc objects, accessable by string name 319 320 Level: advanced 321 322 .seealso: PetscOListAdd(), PetscOListDestroy(), PetscOListFind() 323 S*/ 324 typedef struct _PetscOList *PetscOList; 325 326 EXTERN int PetscOListDestroy(PetscOList *); 327 EXTERN int PetscOListFind(PetscOList,const char[],PetscObject*); 328 EXTERN int PetscOListReverseFind(PetscOList,PetscObject,char**); 329 EXTERN int PetscOListAdd(PetscOList *,const char[],PetscObject); 330 EXTERN int PetscOListDuplicate(PetscOList,PetscOList *); 331 332 /* 333 Dynamic library lists. Lists of names of routines in dynamic 334 link libraries that will be loaded as needed. 335 */ 336 EXTERN int PetscFListAdd(PetscFList*,const char[],const char[],void (*)()); 337 EXTERN int PetscFListDestroy(PetscFList*); 338 EXTERN int PetscFListFind(MPI_Comm,PetscFList,const char[],void (**)()); 339 EXTERN int PetscFListPrintTypes(MPI_Comm,FILE*,const char[],const char[],char *,char *,PetscFList); 340 #if defined(PETSC_USE_DYNAMIC_LIBRARIES) 341 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,0) 342 #else 343 #define PetscFListAddDynamic(a,b,p,c) PetscFListAdd(a,b,p,(void (*)())c) 344 #endif 345 EXTERN int PetscFListDuplicate(PetscFList,PetscFList *); 346 EXTERN int PetscFListView(PetscFList,PetscViewer); 347 EXTERN int PetscFListConcat(const char [],const char [],char []); 348 EXTERN int PetscFListGet(PetscFList,char ***,int*); 349 350 /*S 351 PetscDLLibraryList - Linked list of dynamics libraries to search for functions 352 353 Level: advanced 354 355 PETSC_USE_DYNAMIC_LIBRARIES must be defined in petscconf.h to use dynamic libraries 356 357 .seealso: PetscDLLibraryOpen() 358 S*/ 359 typedef struct _PetscDLLibraryList *PetscDLLibraryList; 360 extern PetscDLLibraryList DLLibrariesLoaded; 361 EXTERN int PetscDLLibraryRetrieve(MPI_Comm,const char[],char *,int,PetscTruth *); 362 EXTERN int PetscDLLibraryOpen(MPI_Comm,const char[],void **); 363 EXTERN int PetscDLLibrarySym(MPI_Comm,PetscDLLibraryList *,const char[],const char[],void **); 364 EXTERN int PetscDLLibraryAppend(MPI_Comm,PetscDLLibraryList *,const char[]); 365 EXTERN int PetscDLLibraryPrepend(MPI_Comm,PetscDLLibraryList *,const char[]); 366 EXTERN int PetscDLLibraryClose(PetscDLLibraryList); 367 EXTERN int PetscDLLibraryPrintPath(void); 368 EXTERN int PetscDLLibraryGetInfo(void *,char *,char **); 369 370 /* 371 Mechanism for translating PETSc object representations between languages 372 Not currently used. 373 */ 374 typedef enum {PETSC_LANGUAGE_C,PETSC_LANGUAGE_CPP} PetscLanguage; 375 #define PETSC_LANGUAGE_F77 PETSC_LANGUAGE_C 376 EXTERN int PetscObjectComposeLanguage(PetscObject,PetscLanguage,void *); 377 EXTERN int PetscObjectQueryLanguage(PetscObject,PetscLanguage,void **); 378 379 /* 380 Useful utility routines 381 */ 382 EXTERN int PetscSplitOwnership(MPI_Comm,int*,int*); 383 EXTERN int PetscSplitOwnershipBlock(MPI_Comm,int,int*,int*); 384 EXTERN int PetscSequentialPhaseBegin(MPI_Comm,int); 385 EXTERN int PetscSequentialPhaseEnd(MPI_Comm,int); 386 EXTERN int PetscBarrier(PetscObject); 387 EXTERN int PetscMPIDump(FILE*); 388 389 #define PetscNot(a) ((a) ? PETSC_FALSE : PETSC_TRUE) 390 /* 391 Defines basic graphics available from PETSc. 392 */ 393 #include "petscdraw.h" 394 395 /* 396 Defines the base data structures for all PETSc objects 397 */ 398 #include "petschead.h" 399 400 /* 401 Defines PETSc profiling. 402 */ 403 #include "petsclog.h" 404 405 /* 406 For locking, unlocking and destroying AMS memories associated with 407 PETSc objects 408 */ 409 #if defined(PETSC_HAVE_AMS) 410 411 extern PetscTruth PetscAMSPublishAll; 412 #define PetscPublishAll(v) (PetscAMSPublishAll ? PetscObjectPublish((PetscObject)v) : 0) 413 #define PetscObjectTakeAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_take_access(((PetscObject)(obj))->amem)) 414 #define PetscObjectGrantAccess(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_grant_access(((PetscObject)(obj))->amem)) 415 #define PetscObjectDepublish(obj) ((((PetscObject)(obj))->amem == -1) ? 0 : AMS_Memory_destroy(((PetscObject)(obj))->amem)); \ 416 ((PetscObject)(obj))->amem = -1; 417 418 #else 419 420 #define PetscPublishAll(v) 0 421 #define PetscObjectTakeAccess(obj) 0 422 #define PetscObjectGrantAccess(obj) 0 423 #define PetscObjectDepublish(obj) 0 424 425 #endif 426 427 428 429 /* 430 This code allows one to pass a MPI communicator between 431 C and Fortran. MPI 2.0 defines a standard API for doing this. 432 The code here is provided to allow PETSc to work with MPI 1.1 433 standard MPI libraries. 434 */ 435 EXTERN int MPICCommToFortranComm(MPI_Comm,int *); 436 EXTERN int MPIFortranCommToCComm(int,MPI_Comm*); 437 438 /* 439 Simple PETSc parallel IO for ASCII printing 440 */ 441 EXTERN int PetscFixFilename(const char[],char[]); 442 EXTERN int PetscFOpen(MPI_Comm,const char[],const char[],FILE**); 443 EXTERN int PetscFClose(MPI_Comm,FILE*); 444 EXTERN int PetscFPrintf(MPI_Comm,FILE*,const char[],...); 445 EXTERN int PetscPrintf(MPI_Comm,const char[],...); 446 EXTERN int (*PetscErrorPrintf)(const char[],...); 447 EXTERN int (*PetscHelpPrintf)(MPI_Comm,const char[],...); 448 EXTERN int PetscPOpen(MPI_Comm,char *,char*,const char[],FILE **); 449 EXTERN int PetscPClose(MPI_Comm,FILE*); 450 EXTERN int PetscSynchronizedPrintf(MPI_Comm,const char[],...); 451 EXTERN int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...); 452 EXTERN int PetscSynchronizedFlush(MPI_Comm); 453 EXTERN int PetscSynchronizedFGets(MPI_Comm,FILE*,int,char[]); 454 EXTERN int PetscStartMatlab(MPI_Comm,char *,char*,FILE**); 455 EXTERN int PetscStartJava(MPI_Comm,char *,char*,FILE**); 456 457 EXTERN int PetscPopUpSelect(MPI_Comm,char*,char*,int,char**,int*); 458 /*S 459 PetscObjectContainer - Simple PETSc object that contains a pointer to any required data 460 461 Level: advanced 462 463 .seealso: PetscObject, PetscObjectContainerCreate() 464 S*/ 465 typedef struct _p_PetscObjectContainer* PetscObjectContainer; 466 EXTERN int PetscObjectContainerGetPointer(PetscObjectContainer,void **); 467 EXTERN int PetscObjectContainerSetPointer(PetscObjectContainer,void *); 468 EXTERN int PetscObjectContainerDestroy(PetscObjectContainer); 469 EXTERN int PetscObjectContainerCreate(MPI_Comm comm,PetscObjectContainer *); 470 471 /* 472 For incremental debugging 473 */ 474 extern PetscTruth PetscCompare; 475 EXTERN int PetscCompareDouble(double); 476 EXTERN int PetscCompareScalar(PetscScalar); 477 EXTERN int PetscCompareInt(int); 478 479 /* 480 For use in debuggers 481 */ 482 extern int PetscGlobalRank,PetscGlobalSize; 483 EXTERN int PetscIntView(int,int[],PetscViewer); 484 EXTERN int PetscRealView(int,PetscReal[],PetscViewer); 485 EXTERN int PetscScalarView(int,PetscScalar[],PetscViewer); 486 487 /* 488 Allows accessing Matlab Engine 489 */ 490 #include "petscengine.h" 491 492 /* 493 C code optimization is often enhanced by telling the compiler 494 that certain pointer arguments to functions are not aliased to 495 to other arguments. This is not yet ANSI C standard so we define 496 the macro "restrict" to indicate that the variable is not aliased 497 to any other argument. 498 */ 499 #if defined(PETSC_HAVE_RESTRICT) && !defined(__cplusplus) 500 #define restrict _Restrict 501 #else 502 #define restrict 503 #endif 504 505 /* 506 Determine if some of the kernel computation routines use 507 Fortran (rather than C) for the numerical calculations. On some machines 508 and compilers (like complex numbers) the Fortran version of the routines 509 is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS 510 would be set in the petscconf.h file 511 */ 512 #if defined(PETSC_USE_FORTRAN_KERNELS) 513 514 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 515 #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 516 #endif 517 518 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 519 #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 520 #endif 521 522 #if !defined(PETSC_USE_FORTRAN_KERNEL_NORMSQR) 523 #define PETSC_USE_FORTRAN_KERNEL_NORMSQR 524 #endif 525 526 #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 527 #define PETSC_USE_FORTRAN_KERNEL_MAXPY 528 #endif 529 530 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 531 #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 532 #endif 533 534 #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 535 #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 536 #endif 537 538 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 539 #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 540 #endif 541 542 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 543 #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 544 #endif 545 546 #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 547 #define PETSC_USE_FORTRAN_KERNEL_MDOT 548 #endif 549 550 #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 551 #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 552 #endif 553 554 #endif 555 556 /* 557 Macros for indicating code that should be compiled with a C interface, 558 rather than a C++ interface. Any routines that are dynamically loaded 559 (such as the PCCreate_XXX() routines) must be wrapped so that the name 560 mangler does not change the functions symbol name. This just hides the 561 ugly extern "C" {} wrappers. 562 */ 563 #if defined(__cplusplus) 564 #define EXTERN_C_BEGIN extern "C" { 565 #define EXTERN_C_END } 566 #else 567 #define EXTERN_C_BEGIN 568 #define EXTERN_C_END 569 #endif 570 571 /* --------------------------------------------------------------------*/ 572 /* 573 DVF (win32) uses STDCALL calling convention by default. 574 The following is used by the fortran interface. 575 */ 576 #if defined (PETSC_USE_FORTRAN_STDCALL) 577 #define PETSC_STDCALL __stdcall 578 #else 579 #define PETSC_STDCALL 580 #endif 581 582 583 /*M 584 size - integer variable used to contain the number of processors in 585 the relevent MPI_Comm 586 587 Level: beginner 588 589 .seealso: rank, comm 590 M*/ 591 592 /*M 593 rank - integer variable used to contain the number of this processor relative 594 to all in the relevent MPI_Comm 595 596 Level: beginner 597 598 .seealso: size, comm 599 M*/ 600 601 /*M 602 comm - MPI_Comm used in the current routine or object 603 604 Level: beginner 605 606 .seealso: size, rank 607 M*/ 608 609 /*M 610 PetscScalar - PETSc type that represents either a double precision real number or 611 a double precision complex number if the code is compiled with BOPT=g_complex or O_complex 612 613 Level: beginner 614 615 M*/ 616 617 /* 618 The IBM include files define hz, here we hide it so that it may be used 619 as a regular user variable. 620 */ 621 #if defined(hz) 622 #undef hz 623 #endif 624 625 #endif 626 627 628