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