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