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