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