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