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