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