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