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