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 petscconf.h is contained in bmake/${PETSC_ARCH}/petscconf.h it is 18 found automatically by the compiler due to the -I${PETSC_DIR}/bmake/${PETSC_ARCH} 19 in the bmake/common_variables definition of PETSC_INCLUDE 20 */ 21 #include "petscconf.h" 22 /* 23 Fixes for configure time choices which impact our interface. Currently only 24 calling conventions and extra compiler checking falls under this category. 25 */ 26 #if !defined(PETSC_PRINTF_FORMAT_CHECK) 27 #define PETSC_PRINTF_FORMAT_CHECK(a,b) 28 #endif 29 #if !defined (PETSC_STDCALL) 30 #define PETSC_STDCALL 31 #endif 32 #if !defined (PETSC_TEMPLATE) 33 #define PETSC_TEMPLATE 34 #endif 35 36 /* ========================================================================== */ 37 38 #include <stdio.h> 39 /* 40 Defines the interface to MPI allowing the use of all MPI functions. 41 */ 42 #include "mpi.h" 43 44 /* 45 EXTERN indicates a PETSc function defined elsewhere 46 */ 47 #define EXTERN extern 48 49 /* 50 Defines some elementary mathematics functions and constants. 51 */ 52 #include "petscmath.h" 53 54 /* 55 Basic PETSc constants 56 */ 57 58 /*E 59 PetscTruth - Logical variable. Actually an integer 60 61 Level: beginner 62 63 E*/ 64 typedef enum { PETSC_FALSE,PETSC_TRUE } PetscTruth; 65 66 #define PETSC_NULL 0 67 #define PETSC_DECIDE -1 68 #define PETSC_DEFAULT -2 69 70 #define PETSC_YES PETSC_TRUE 71 #define PETSC_NO PETSC_FALSE 72 #define PETSC_IGNORE PETSC_NULL 73 #define PETSC_DETERMINE PETSC_DECIDE 74 75 76 extern MPI_Comm PETSC_COMM_WORLD; 77 extern MPI_Comm PETSC_COMM_SELF; 78 extern PetscTruth PetscInitializeCalled; 79 EXTERN int PetscSetCommWorld(MPI_Comm); 80 EXTERN int PetscSetHelpVersionFunctions(int (*)(MPI_Comm),int (*)(MPI_Comm)); 81 82 /*MC 83 PetscMalloc - Allocates memory 84 85 Input Parameter: 86 . m - number of bytes to allocate 87 88 Output Parameter: 89 . result - memory allocated 90 91 Synopsis: 92 int PetscMalloc(int m,void **result) 93 94 Level: beginner 95 96 Notes: Memory is always allocated at least double aligned 97 98 .seealso: PetscFree(), PetscNew() 99 100 Concepts: memory allocation 101 102 M*/ 103 #define PetscMalloc(a,b) (*PetscTrMalloc)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__,(void**)(b)) 104 /*MC 105 PetscNew - Allocates memory of a particular type 106 107 Input Parameter: 108 . type - structure name of space to be allocated. Memory of size sizeof(type) is allocated 109 110 Output Parameter: 111 . result - memory allocated 112 113 Synopsis: 114 int PetscNew(struct type,((type *))result) 115 116 Level: beginner 117 118 .seealso: PetscFree(), PetscMalloc() 119 120 Concepts: memory allocation 121 122 M*/ 123 #define PetscNew(A,b) PetscMalloc(sizeof(A),(b)) 124 /*MC 125 PetscFree - Frees memory 126 127 Input Parameter: 128 . memory - memory to free 129 130 Synopsis: 131 int PetscFree(void *memory) 132 133 Level: beginner 134 135 Notes: Memory must have been obtained with PetscNew() or PetscMalloc() 136 137 .seealso: PetscNew(), PetscMalloc() 138 139 Concepts: memory allocation 140 141 M*/ 142 #define PetscFree(a) (*PetscTrFree)((a),__LINE__,__FUNCT__,__FILE__,__SDIR__) 143 EXTERN int (*PetscTrMalloc)(int,int,char*,char*,char*,void**); 144 EXTERN int (*PetscTrFree)(void *,int,char*,char*,char*); 145 EXTERN int PetscSetMalloc(int (*)(int,int,char*,char*,char*,void**),int (*)(void *,int,char*,char*,char*)); 146 EXTERN int PetscClearMalloc(void); 147 148 /* 149 Routines for tracing memory corruption/bleeding with default PETSc 150 memory allocation 151 */ 152 EXTERN int PetscTrDump(FILE *); 153 EXTERN int PetscTrSpace(PetscLogDouble *,PetscLogDouble *,PetscLogDouble *); 154 EXTERN int PetscTrValid(int,const char[],const char[],const char[]); 155 EXTERN int PetscTrDebugLevel(int); 156 EXTERN int PetscTrLog(void); 157 EXTERN int PetscTrLogDump(FILE *); 158 EXTERN int PetscGetResidentSetSize(PetscLogDouble *); 159 160 /* 161 Variable type where we stash PETSc object pointers in Fortran. 162 Assumes that sizeof(long) == sizeof(void*)which is true on 163 all machines that we know. 164 */ 165 #define PetscFortranAddr long 166 167 /*E 168 PetscDataType - Used for handling different basic data types. 169 170 Level: beginner 171 172 .seealso: PetscBinaryRead(), PetscBinaryWrite(), PetscDataTypeToMPIDataType(), 173 PetscDataTypeGetSize(), PetscDataTypeGetName() 174 175 E*/ 176 typedef enum {PETSC_INT = 0,PETSC_DOUBLE = 1,PETSC_COMPLEX = 2, 177 PETSC_LONG =3 ,PETSC_SHORT = 4,PETSC_FLOAT = 5, 178 PETSC_CHAR = 6,PETSC_LOGICAL = 7} PetscDataType; 179 #if defined(PETSC_USE_COMPLEX) 180 #define PETSC_SCALAR PETSC_COMPLEX 181 #else 182 #if defined(PETSC_USE_SINGLE) 183 #define PETSC_SCALAR PETSC_FLOAT 184 #else 185 #define PETSC_SCALAR PETSC_DOUBLE 186 #endif 187 #endif 188 #if defined(PETSC_USE_SINGLE) 189 #define PETSC_REAL PETSC_FLOAT 190 #else 191 #define PETSC_REAL PETSC_DOUBLE 192 #endif 193 #define PETSC_FORTRANADDR PETSC_LONG 194 195 EXTERN int PetscDataTypeToMPIDataType(PetscDataType,MPI_Datatype*); 196 EXTERN int PetscDataTypeGetSize(PetscDataType,int*); 197 EXTERN int PetscDataTypeGetName(PetscDataType,char*[]); 198 199 /* 200 Basic memory and string operations. These are usually simple wrappers 201 around the basic Unix system calls, but a few of them have additional 202 functionality and/or error checking. 203 */ 204 EXTERN int PetscMemcpy(void *,const void *,int); 205 EXTERN int PetscBitMemcpy(void*,int,const void*,int,int,PetscDataType); 206 EXTERN int PetscMemmove(void *,void *,int); 207 EXTERN int PetscMemzero(void *,int); 208 EXTERN int PetscMemcmp(const void*,const void*,int,PetscTruth *); 209 EXTERN int PetscStrlen(const char[],int*); 210 EXTERN int PetscStrcmp(const char[],const char[],PetscTruth *); 211 EXTERN int PetscStrgrt(const char[],const char[],PetscTruth *); 212 EXTERN int PetscStrcasecmp(const char[],const char[],PetscTruth*); 213 EXTERN int PetscStrncmp(const char[],const char[],int,PetscTruth*); 214 EXTERN int PetscStrcpy(char[],const char[]); 215 EXTERN int PetscStrcat(char[],const char[]); 216 EXTERN int PetscStrncat(char[],const char[],int); 217 EXTERN int PetscStrncpy(char[],const char[],int); 218 EXTERN int PetscStrchr(const char[],char,char **); 219 EXTERN int PetscStrtolower(char[]); 220 EXTERN int PetscStrrchr(const char[],char,char **); 221 EXTERN int PetscStrstr(const char[],const char[],char **); 222 EXTERN int PetscStrallocpy(const char[],char **); 223 EXTERN int PetscStrreplace(MPI_Comm,const char[],char*,int); 224 #define PetscStrfree(a) ((a) ? PetscFree(a) : 0) 225 typedef struct {char token;char *array;char *current;} PetscToken; 226 EXTERN int PetscTokenCreate(const char[],const char,PetscToken**); 227 EXTERN int PetscTokenFind(PetscToken*,char **); 228 EXTERN int PetscTokenDestroy(PetscToken*); 229 230 /* 231 These are MPI operations for MPI_Allreduce() etc 232 */ 233 EXTERN MPI_Op PetscMaxSum_Op; 234 #if defined(PETSC_USE_COMPLEX) 235 EXTERN MPI_Op PetscSum_Op; 236 #else 237 #define PetscSum_Op MPI_SUM 238 #endif 239 240 /*S 241 PetscObject - any PETSc object, PetscViewer, Mat, Vec, SLES etc 242 243 Level: beginner 244 245 .seealso: PetscObjectDestroy(), PetscObjectView(), PetscObjectGetName(), PetscObjectSetName() 246 S*/ 247 typedef struct _p_PetscObject* PetscObject; 248 249 /*S 250 PetscFList - Linked list of functions, possibly stored in dynamic libraries, accessed 251 by string name 252 253 Level: advanced 254 255 .seealso: PetscFListAdd(), PetscFListDestroy() 256 S*/ 257 typedef struct _PetscFList *PetscFList; 258 259 #include "petscviewer.h" 260 #include "petscoptions.h" 261 262 EXTERN int PetscShowMemoryUsage(PetscViewer,char*); 263 EXTERN int PetscGetTime(PetscLogDouble*); 264 EXTERN int PetscGetCPUTime(PetscLogDouble*); 265 EXTERN int PetscSleep(int); 266 267 /* 268 Initialization of PETSc 269 */ 270 EXTERN int PetscInitialize(int*,char***,char[],const char[]); 271 EXTERN int PetscInitializeNoArguments(void); 272 EXTERN int PetscFinalize(void); 273 EXTERN int PetscInitializeFortran(void); 274 EXTERN int PetscGetArgs(int*,char ***); 275 EXTERN int PetscEnd(void); 276 277 /* 278 ParameterDict is an abstraction for arguments to interface mechanisms 279 */ 280 extern int DICT_COOKIE; 281 typedef struct _p_Dict *ParameterDict; 282 283 typedef void (**PetscVoidFunction)(void); 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,(PetscVoidFunction)&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,(PetscVoidFunction)&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[],...) PETSC_PRINTF_FORMAT_CHECK(3,4); 476 EXTERN int PetscPrintf(MPI_Comm,const char[],...) PETSC_PRINTF_FORMAT_CHECK(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[],...) PETSC_PRINTF_FORMAT_CHECK(2,3); 482 EXTERN int PetscSynchronizedFPrintf(MPI_Comm,FILE*,const char[],...) PETSC_PRINTF_FORMAT_CHECK(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 #if defined(restrict) 535 #undef restrict 536 #endif 537 #define restrict 538 #endif 539 540 /* 541 Determine if some of the kernel computation routines use 542 Fortran (rather than C) for the numerical calculations. On some machines 543 and compilers (like complex numbers) the Fortran version of the routines 544 is faster than the C/C++ versions. The flag PETSC_USE_FORTRAN_KERNELS 545 would be set in the petscconf.h file 546 */ 547 #if defined(PETSC_USE_FORTRAN_KERNELS) 548 549 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTAIJ) 550 #define PETSC_USE_FORTRAN_KERNEL_MULTAIJ 551 #endif 552 553 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ) 554 #define PETSC_USE_FORTRAN_KERNEL_MULTTRANSPOSEAIJ 555 #endif 556 557 #if !defined(PETSC_USE_FORTRAN_KERNEL_NORM) 558 #define PETSC_USE_FORTRAN_KERNEL_NORM 559 #endif 560 561 #if !defined(PETSC_USE_FORTRAN_KERNEL_MAXPY) 562 #define PETSC_USE_FORTRAN_KERNEL_MAXPY 563 #endif 564 565 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ) 566 #define PETSC_USE_FORTRAN_KERNEL_SOLVEAIJ 567 #endif 568 569 #if !defined(PETSC_USE_FORTRAN_KERNEL_RELAXAIJ) 570 #define PETSC_USE_FORTRAN_KERNEL_RELAXAIJ 571 #endif 572 573 #if !defined(PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ) 574 #define PETSC_USE_FORTRAN_KERNEL_SOLVEBAIJ 575 #endif 576 577 #if !defined(PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ) 578 #define PETSC_USE_FORTRAN_KERNEL_MULTADDAIJ 579 #endif 580 581 #if !defined(PETSC_USE_FORTRAN_KERNEL_MDOT) 582 #define PETSC_USE_FORTRAN_KERNEL_MDOT 583 #endif 584 585 #if !defined(PETSC_USE_FORTRAN_KERNEL_XTIMESY) 586 #define PETSC_USE_FORTRAN_KERNEL_XTIMESY 587 #endif 588 589 #if !defined(PETSC_USE_FORTRAN_KERNEL_AYPX) 590 #define PETSC_USE_FORTRAN_KERNEL_AYPX 591 #endif 592 593 #if !defined(PETSC_USE_FORTRAN_KERNEL_WAXPY) 594 #define PETSC_USE_FORTRAN_KERNEL_WAXPY 595 #endif 596 597 #endif 598 599 /* 600 Macros for indicating code that should be compiled with a C interface, 601 rather than a C++ interface. Any routines that are dynamically loaded 602 (such as the PCCreate_XXX() routines) must be wrapped so that the name 603 mangler does not change the functions symbol name. This just hides the 604 ugly extern "C" {} wrappers. 605 */ 606 #if defined(__cplusplus) 607 #define EXTERN_C_BEGIN extern "C" { 608 #define EXTERN_C_END } 609 #else 610 #define EXTERN_C_BEGIN 611 #define EXTERN_C_END 612 #endif 613 614 /* --------------------------------------------------------------------*/ 615 616 /*M 617 size - integer variable used to contain the number of processors in 618 the relevent MPI_Comm 619 620 Level: beginner 621 622 .seealso: rank, comm 623 M*/ 624 625 /*M 626 rank - integer variable used to contain the number of this processor relative 627 to all in the relevent MPI_Comm 628 629 Level: beginner 630 631 .seealso: size, comm 632 M*/ 633 634 /*M 635 comm - MPI_Comm used in the current routine or object 636 637 Level: beginner 638 639 .seealso: size, rank 640 M*/ 641 642 /*M 643 PetscScalar - PETSc type that represents either a double precision real number or 644 a double precision complex number if the code is compiled with BOPT=g_complex or O_complex 645 646 Level: beginner 647 648 M*/ 649 650 /* 651 The IBM include files define hz, here we hide it so that it may be used 652 as a regular user variable. 653 */ 654 #if defined(hz) 655 #undef hz 656 #endif 657 658 #endif 659 660 661