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