Date: 2023-09-05T10:18:46+00:00

Actual source code: slepcinit.c
slepc-3.19.2 2023-09-05
Report Typos and Errors

      1: /*
      2:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      3:    SLEPc - Scalable Library for Eigenvalue Problem Computations
      4:    Copyright (c) 2002-, Universitat Politecnica de Valencia, Spain

      6:    This file is part of SLEPc.
      7:    SLEPc is distributed under a 2-clause BSD license (see LICENSE).
      8:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      9: */

     11: #include <slepc/private/slepcimpl.h>

     13: #if defined(SLEPC_HAVE_HPDDM)
     14: #include <petscksp.h>
     15: SLEPC_EXTERN PetscErrorCode KSPCreate_HPDDM(KSP);
     16: SLEPC_EXTERN PetscErrorCode PCCreate_HPDDM(PC);
     17: #endif

     19: /*@C
     20:     SlepcGetVersion - Gets the SLEPc version information in a string.

     22:     Not Collective

     24:     Input Parameter:
     25: .   len - length of the string

     27:     Output Parameter:
     28: .   version - version string

     30:     Level: intermediate

     32: .seealso: SlepcGetVersionNumber()
     33: @*/
     34: PetscErrorCode SlepcGetVersion(char version[],size_t len)
     35: {
     36:   PetscFunctionBegin;
     37: #if (SLEPC_VERSION_RELEASE == 1)
     38:   PetscCall(PetscSNPrintf(version,len,"SLEPc Release Version %d.%d.%d, %s",SLEPC_VERSION_MAJOR,SLEPC_VERSION_MINOR,SLEPC_VERSION_SUBMINOR,SLEPC_VERSION_DATE));
     39: #else
     40:   PetscCall(PetscSNPrintf(version,len,"SLEPc Development GIT revision: %s  GIT Date: %s",SLEPC_VERSION_GIT,SLEPC_VERSION_DATE_GIT));
     41: #endif
     42:   PetscFunctionReturn(PETSC_SUCCESS);
     43: }

     45: /*@C
     46:     SlepcGetVersionNumber - Gets the SLEPc version information from the library.

     48:     Not Collective

     50:     Output Parameters:
     51: +   major    - the major version
     52: .   minor    - the minor version
     53: .   subminor - the subminor version (patch number)
     54: -   release  - indicates the library is from a release

     56:     Notes:
     57:     Pass NULL in any argument that is not requested.

     59:     The C macros SLEPC_VERSION_MAJOR, SLEPC_VERSION_MINOR, SLEPC_VERSION_SUBMINOR,
     60:     SLEPC_VERSION_RELEASE provide the information at compile time. This can be used to confirm
     61:     that the shared library being loaded at runtime has the appropriate version updates.

     63:     This function can be called before SlepcInitialize().

     65:     Level: intermediate

     67: .seealso: SlepcGetVersion(), SlepcInitialize()
     68: @*/
     69: PetscErrorCode SlepcGetVersionNumber(PetscInt *major,PetscInt *minor,PetscInt *subminor,PetscInt *release)
     70: {
     71:   if (major)    *major    = SLEPC_VERSION_MAJOR;
     72:   if (minor)    *minor    = SLEPC_VERSION_MINOR;
     73:   if (subminor) *subminor = SLEPC_VERSION_SUBMINOR;
     74:   if (release)  *release  = SLEPC_VERSION_RELEASE;
     75:   return PETSC_SUCCESS;
     76: }

     78: /*
     79:    SlepcPrintVersion - Prints SLEPc version info.

     81:    Collective
     82: */
     83: static PetscErrorCode SlepcPrintVersion(MPI_Comm comm)
     84: {
     85:   char           version[256];

     87:   PetscFunctionBegin;
     88:   PetscCall(SlepcGetVersion(version,256));
     89:   PetscCall((*PetscHelpPrintf)(comm,"%s\n",version));
     90:   PetscCall((*PetscHelpPrintf)(comm,SLEPC_AUTHOR_INFO));
     91:   PetscCall((*PetscHelpPrintf)(comm,"See docs/manual.html for help.\n"));
     92:   PetscCall((*PetscHelpPrintf)(comm,"SLEPc libraries linked from %s\n",SLEPC_LIB_DIR));
     93:   PetscFunctionReturn(PETSC_SUCCESS);
     94: }

     96: /*
     97:    SlepcPrintHelpIntro - Prints introductory SLEPc help info.

     99:    Collective
    100: */
    101: static PetscErrorCode SlepcPrintHelpIntro(MPI_Comm comm)
    102: {
    103:   PetscFunctionBegin;
    104:   PetscCall((*PetscHelpPrintf)(comm,"SLEPc help information includes that for the PETSc libraries, which provide\n"));
    105:   PetscCall((*PetscHelpPrintf)(comm,"low-level system infrastructure and linear algebra tools.\n"));
    106:   PetscCall((*PetscHelpPrintf)(comm,"----------------------------------------\n"));
    107:   PetscFunctionReturn(PETSC_SUCCESS);
    108: }

    110: /* ------------------------Nasty global variables -------------------------------*/
    111: /*
    112:    Indicates whether SLEPc started PETSc, or whether it was
    113:    already started before SLEPc was initialized.
    114: */
    115: PetscBool SlepcBeganPetsc       = PETSC_FALSE;
    116: PetscBool SlepcInitializeCalled = PETSC_FALSE;
    117: PetscBool SlepcFinalizeCalled   = PETSC_FALSE;

    119: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES)
    120: static PetscErrorCode SlepcLoadDynamicLibrary(const char *name,PetscBool *found)
    121: {
    122:   char           libs[PETSC_MAX_PATH_LEN],dlib[PETSC_MAX_PATH_LEN];

    124:   PetscFunctionBegin;
    125:   PetscCall(PetscStrcpy(libs,SLEPC_LIB_DIR));
    126:   PetscCall(PetscStrlcat(libs,"/libslepc",sizeof(libs)));
    127:   PetscCall(PetscStrlcat(libs,name,sizeof(libs)));
    128:   PetscCall(PetscDLLibraryRetrieve(PETSC_COMM_WORLD,libs,dlib,sizeof(dlib),found));
    129:   if (*found) PetscCall(PetscDLLibraryAppend(PETSC_COMM_WORLD,&PetscDLLibrariesLoaded,dlib));
    130:   PetscFunctionReturn(PETSC_SUCCESS);
    131: }
    132: #endif

    134: #if defined(PETSC_USE_SINGLE_LIBRARY) && !(defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES))
    135: SLEPC_EXTERN PetscErrorCode STInitializePackage(void);
    136: SLEPC_EXTERN PetscErrorCode DSInitializePackage(void);
    137: SLEPC_EXTERN PetscErrorCode FNInitializePackage(void);
    138: SLEPC_EXTERN PetscErrorCode BVInitializePackage(void);
    139: SLEPC_EXTERN PetscErrorCode RGInitializePackage(void);
    140: SLEPC_EXTERN PetscErrorCode EPSInitializePackage(void);
    141: SLEPC_EXTERN PetscErrorCode SVDInitializePackage(void);
    142: SLEPC_EXTERN PetscErrorCode PEPInitializePackage(void);
    143: SLEPC_EXTERN PetscErrorCode NEPInitializePackage(void);
    144: SLEPC_EXTERN PetscErrorCode MFNInitializePackage(void);
    145: SLEPC_EXTERN PetscErrorCode LMEInitializePackage(void);
    146: #endif

    148: /*
    149:     SlepcInitialize_DynamicLibraries - Adds the default dynamic link libraries to the
    150:     search path.
    151: */
    152: PetscErrorCode SlepcInitialize_DynamicLibraries(void)
    153: {
    154:   PetscBool      preload = PETSC_FALSE;

    156:   PetscFunctionBegin;
    157: #if defined(PETSC_HAVE_THREADSAFETY)
    158:   /* These must be all initialized here because it is not safe for individual threads to call these initialize routines */
    159:   preload = PETSC_TRUE;
    160: #endif

    162:   PetscCall(PetscOptionsGetBool(NULL,NULL,"-library_preload",&preload,NULL));
    163:   if (preload) {
    164: #if defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES)
    165:     PetscBool found;
    166: #if defined(PETSC_USE_SINGLE_LIBRARY)
    167:     PetscCall(SlepcLoadDynamicLibrary("",&found));
    168:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc dynamic library\nYou cannot move the dynamic libraries!");
    169: #else
    170:     PetscCall(SlepcLoadDynamicLibrary("sys",&found));
    171:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc sys dynamic library\nYou cannot move the dynamic libraries!");
    172:     PetscCall(SlepcLoadDynamicLibrary("eps",&found));
    173:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc EPS dynamic library\nYou cannot move the dynamic libraries!");
    174:     PetscCall(SlepcLoadDynamicLibrary("pep",&found));
    175:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc PEP dynamic library\nYou cannot move the dynamic libraries!");
    176:     PetscCall(SlepcLoadDynamicLibrary("nep",&found));
    177:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc NEP dynamic library\nYou cannot move the dynamic libraries!");
    178:     PetscCall(SlepcLoadDynamicLibrary("svd",&found));
    179:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc SVD dynamic library\nYou cannot move the dynamic libraries!");
    180:     PetscCall(SlepcLoadDynamicLibrary("mfn",&found));
    181:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc MFN dynamic library\nYou cannot move the dynamic libraries!");
    182:     PetscCall(SlepcLoadDynamicLibrary("lme",&found));
    183:     PetscCheck(found,PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Unable to locate SLEPc LME dynamic library\nYou cannot move the dynamic libraries!");
    184: #endif
    185: #else /* defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES) */
    186: #if defined(PETSC_USE_SINGLE_LIBRARY)
    187:   PetscCall(STInitializePackage());
    188:   PetscCall(DSInitializePackage());
    189:   PetscCall(FNInitializePackage());
    190:   PetscCall(BVInitializePackage());
    191:   PetscCall(RGInitializePackage());
    192:   PetscCall(EPSInitializePackage());
    193:   PetscCall(SVDInitializePackage());
    194:   PetscCall(PEPInitializePackage());
    195:   PetscCall(NEPInitializePackage());
    196:   PetscCall(MFNInitializePackage());
    197:   PetscCall(LMEInitializePackage());
    198: #else
    199:   SETERRQ(PETSC_COMM_WORLD,PETSC_ERR_SUP,"Cannot use -library_preload with multiple static SLEPc libraries");
    200: #endif
    201: #endif /* defined(PETSC_HAVE_DYNAMIC_LIBRARIES) && defined(PETSC_USE_SHARED_LIBRARIES) */
    202:   }

    204: #if defined(SLEPC_HAVE_HPDDM)
    205:   PetscCall(KSPRegister(KSPHPDDM,KSPCreate_HPDDM));
    206:   PetscCall(PCRegister(PCHPDDM,PCCreate_HPDDM));
    207: #endif
    208:   PetscFunctionReturn(PETSC_SUCCESS);
    209: }

    211: PetscErrorCode SlepcCitationsInitialize(void)
    212: {
    213:   PetscFunctionBegin;
    214:   PetscCall(PetscCitationsRegister("@Article{slepc-toms,\n"
    215:     "   author = \"Vicente Hernandez and Jose E. Roman and Vicente Vidal\",\n"
    216:     "   title = \"{SLEPc}: A Scalable and Flexible Toolkit for the Solution of Eigenvalue Problems\",\n"
    217:     "   journal = \"{ACM} Trans. Math. Software\",\n"
    218:     "   volume = \"31\",\n"
    219:     "   number = \"3\",\n"
    220:     "   pages = \"351--362\",\n"
    221:     "   year = \"2005\",\n"
    222:     "   doi = \"https://doi.org/10.1145/1089014.1089019\"\n"
    223:     "}\n",NULL));
    224:   PetscCall(PetscCitationsRegister("@TechReport{slepc-manual,\n"
    225:     "   author = \"J. E. Roman and C. Campos and L. Dalcin and E. Romero and A. Tomas\",\n"
    226:     "   title = \"{SLEPc} Users Manual\",\n"
    227:     "   number = \"DSIC-II/24/02 - Revision 3.19\",\n"
    228:     "   institution = \"D. Sistemes Inform\\`atics i Computaci\\'o, Universitat Polit\\`ecnica de Val\\`encia\",\n"
    229:     "   year = \"2023\"\n"
    230:     "}\n",NULL));
    231:   PetscFunctionReturn(PETSC_SUCCESS);
    232: }

    234: /*@C
    235:    SlepcInitialize - Initializes the SLEPc library. SlepcInitialize() calls
    236:    PetscInitialize() if that has not been called yet, so this routine should
    237:    always be called near the beginning of your program.

    239:    Collective on MPI_COMM_WORLD or PETSC_COMM_WORLD if it has been set

    241:    Input Parameters:
    242: +  argc - count of number of command line arguments
    243: .  args - the command line arguments
    244: .  file - [optional] PETSc database file, defaults to ~username/.petscrc
    245:           (use NULL for default)
    246: -  help - [optional] Help message to print, use NULL for no message

    248:    Fortran Notes:
    249:    Fortran syntax is very similar to that of PetscInitialize()

    251:    Level: beginner

    253: .seealso: SlepcFinalize(), PetscInitialize()
    254: @*/
    255: PetscErrorCode SlepcInitialize(int *argc,char ***args,const char file[],const char help[])
    256: {
    257:   PetscBool      flg;

    259:   PetscFunctionBegin;
    260:   if (SlepcInitializeCalled) PetscFunctionReturn(PETSC_SUCCESS);
    261:   PetscCall(PetscSetHelpVersionFunctions(SlepcPrintHelpIntro,SlepcPrintVersion));
    262:   PetscCall(PetscInitialized(&flg));
    263:   if (!flg) {
    264:     PetscCall(PetscInitialize(argc,args,file,help));
    265:     SlepcBeganPetsc = PETSC_TRUE;
    266:   }

    268:   PetscCall(SlepcCitationsInitialize());

    270:   /* Load the dynamic libraries (on machines that support them), this registers all the solvers etc. */
    271:   PetscCall(SlepcInitialize_DynamicLibraries());

    273:   SlepcInitializeCalled = PETSC_TRUE;
    274:   SlepcFinalizeCalled   = PETSC_FALSE;
    275:   PetscCall(PetscInfo(0,"SLEPc successfully started\n"));
    276:   PetscFunctionReturn(PETSC_SUCCESS);
    277: }

    279: /*@C
    280:    SlepcFinalize - Checks for options to be called at the conclusion
    281:    of the SLEPc program and calls PetscFinalize().

    283:    Collective on PETSC_COMM_WORLD

    285:    Level: beginner

    287: .seealso: SlepcInitialize(), PetscFinalize()
    288: @*/
    289: PetscErrorCode SlepcFinalize(void)
    290: {
    291:   PetscFunctionBegin;
    292:   if (PetscUnlikely(!SlepcInitializeCalled)) {
    293:     fprintf(PETSC_STDOUT,"SlepcInitialize() must be called before SlepcFinalize()\n");
    294:     PetscStackClearTop;
    295:     return PETSC_ERR_ARG_WRONGSTATE;
    296:   }
    297:   PetscCall(PetscInfo(NULL,"SlepcFinalize() called\n"));
    298:   if (SlepcBeganPetsc) {
    299:     PetscCall(PetscFinalize());
    300:     SlepcBeganPetsc = PETSC_FALSE;
    301:   }
    302:   SlepcInitializeCalled = PETSC_FALSE;
    303:   SlepcFinalizeCalled   = PETSC_TRUE;
    304:   PetscFunctionReturn(PETSC_SUCCESS);
    305: }

    307: /*@C
    308:    SlepcInitializeNoArguments - Calls SlepcInitialize() from C/C++ without
    309:    the command line arguments.

    311:    Collective

    313:    Level: advanced

    315: .seealso: SlepcInitialize(), SlepcInitializeFortran()
    316: @*/
    317: PetscErrorCode SlepcInitializeNoArguments(void)
    318: {
    319:   int  argc = 0;
    320:   char **args = NULL;

    322:   PetscFunctionBegin;
    323:   PetscCall(SlepcInitialize(&argc,&args,NULL,NULL));
    324:   PetscFunctionReturn(PETSC_SUCCESS);
    325: }

    327: /*@
    328:    SlepcInitialized - Determine whether SLEPc is initialized.

    330:    Output Parameter:
    331: .  isInitialized - the result

    333:    Level: beginner

    335: .seealso: SlepcInitialize(), SlepcInitializeFortran()
    336: @*/
    337: PetscErrorCode SlepcInitialized(PetscBool *isInitialized)
    338: {
    339:   PetscFunctionBegin;
    340:   *isInitialized = SlepcInitializeCalled;
    341:   PetscFunctionReturn(PETSC_SUCCESS);
    342: }

    344: /*@
    345:    SlepcFinalized - Determine whether SlepcFinalize() has been called.

    347:    Output Parameter:
    348: .  isFinalized - the result

    350:    Level: developer

    352: .seealso: SlepcFinalize()
    353: @*/
    354: PetscErrorCode SlepcFinalized(PetscBool *isFinalized)
    355: {
    356:   PetscFunctionBegin;
    357:   *isFinalized = SlepcFinalizeCalled;
    358:   PetscFunctionReturn(PETSC_SUCCESS);
    359: }

    361: PETSC_EXTERN PetscBool PetscBeganMPI;

    363: /*@C
    364:    SlepcInitializeNoPointers - Calls SlepcInitialize() from C/C++ without the pointers
    365:    to argc and args (analogue to PetscInitializeNoPointers).

    367:    Collective

    369:    Input Parameters:
    370: +  argc - count of number of command line arguments
    371: .  args - the command line arguments
    372: .  file - [optional] PETSc database file, defaults to ~username/.petscrc
    373:           (use NULL for default)
    374: -  help - [optional] Help message to print, use NULL for no message

    376:    Level: advanced

    378: .seealso: SlepcInitialize()
    379: @*/
    380: PetscErrorCode SlepcInitializeNoPointers(int argc,char **args,const char *file,const char *help)
    381: {
    382:   int            myargc = argc;
    383:   char           **myargs = args;

    385:   PetscFunctionBegin;
    386:   PetscCall(SlepcInitialize(&myargc,&myargs,file,help));
    387:   PetscCall(PetscPopSignalHandler());
    388:   PetscBeganMPI = PETSC_FALSE;
    389:   PetscFunctionReturn(PETSC_SUCCESS);
    390: }